Merge from 'main' to 'sycl-web' (intel#70)

  CONFLICT (content): Merge conflict in llvm/lib/Support/CMakeLists.txt

Author: asudarsa

clang-tools-extra/clang-tidy/ClangTidyCheck.cpp

@@ -147,7 +147,7 @@ llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
 
   StringRef Value = Iter->getValue().Value;
   StringRef Closest;
-  unsigned EditDistance = -1;
+  unsigned EditDistance = 3;
   for (const auto &NameAndEnum : Mapping) {
     if (IgnoreCase) {
       if (Value.equals_lower(NameAndEnum.second))
@@ -159,7 +159,8 @@ llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
       EditDistance = 0;
       continue;
     }
-    unsigned Distance = Value.edit_distance(NameAndEnum.second);
+    unsigned Distance =
+        Value.edit_distance(NameAndEnum.second, true, EditDistance);
     if (Distance < EditDistance) {
       EditDistance = Distance;
       Closest = NameAndEnum.second;

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -571,7 +571,6 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
       {"referencesProvider", true},
       {"astProvider", true}, // clangd extension
       {"typeHierarchyProvider", true},
-      {"clangdInlayHintsProvider", true},
       {"memoryUsageProvider", true}, // clangd extension
       {"compilationDatabase",        // clangd extension
        llvm::json::Object{{"automaticReload", true}}},
@@ -608,6 +607,9 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   if (Opts.FoldingRanges)
     ServerCaps["foldingRangeProvider"] = true;
 
+  if (Opts.InlayHints)
+    ServerCaps["clangdInlayHintsProvider"] = true;
+
   std::vector<llvm::StringRef> Commands;
   for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
     Commands.push_back(Command);

clang-tools-extra/clangd/ClangdLSPServer.h

@@ -62,6 +62,9 @@ class ClangdLSPServer : private ClangdServer::Callbacks,
     std::function<bool(const Tweak &)> TweakFilter = [](const Tweak &T) {
       return !T.hidden(); // only enable non-hidden tweaks.
     };
+
+    /// Enable preview of InlayHints feature.
+    bool InlayHints = false;
   };
 
   ClangdLSPServer(Transport &Transp, const ThreadsafeFS &TFS,

clang-tools-extra/clangd/HeuristicResolver.cpp

@@ -130,6 +130,15 @@ HeuristicResolver::resolveTypeOfCallExpr(const CallExpr *CE) const {
   return {};
 }
 
+std::vector<const NamedDecl *>
+HeuristicResolver::resolveCalleeOfCallExpr(const CallExpr *CE) const {
+  if (const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {
+    return {ND};
+  }
+
+  return resolveExprToDecls(CE->getCallee());
+}
+
 std::vector<const NamedDecl *> HeuristicResolver::resolveUsingValueDecl(
     const UnresolvedUsingValueDecl *UUVD) const {
   return resolveDependentMember(UUVD->getQualifier()->getAsType(),
@@ -163,18 +172,30 @@ const Type *resolveDeclsToType(const std::vector<const NamedDecl *> &Decls) {
   return nullptr;
 }
 
-const Type *HeuristicResolver::resolveExprToType(const Expr *E) const {
+std::vector<const NamedDecl *>
+HeuristicResolver::resolveExprToDecls(const Expr *E) const {
   if (const auto *ME = dyn_cast<CXXDependentScopeMemberExpr>(E)) {
-    return resolveDeclsToType(resolveMemberExpr(ME));
+    return resolveMemberExpr(ME);
   }
   if (const auto *RE = dyn_cast<DependentScopeDeclRefExpr>(E)) {
-    return resolveDeclsToType(resolveDeclRefExpr(RE));
+    return resolveDeclRefExpr(RE);
+  }
+  if (const auto *OE = dyn_cast<OverloadExpr>(E)) {
+    return {OE->decls_begin(), OE->decls_end()};
   }
   if (const auto *CE = dyn_cast<CallExpr>(E)) {
-    return resolveDeclsToType(resolveTypeOfCallExpr(CE));
+    return resolveTypeOfCallExpr(CE);
   }
   if (const auto *ME = dyn_cast<MemberExpr>(E))
-    return resolveDeclsToType({ME->getMemberDecl()});
+    return {ME->getMemberDecl()};
+
+  return {};
+}
+
+const Type *HeuristicResolver::resolveExprToType(const Expr *E) const {
+  std::vector<const NamedDecl *> Decls = resolveExprToDecls(E);
+  if (!Decls.empty())
+    return resolveDeclsToType(Decls);
 
   return E->getType().getTypePtr();
 }

clang-tools-extra/clangd/HeuristicResolver.h

@@ -56,6 +56,8 @@ class HeuristicResolver {
   std::vector<const NamedDecl *>
   resolveTypeOfCallExpr(const CallExpr *CE) const;
   std::vector<const NamedDecl *>
+  resolveCalleeOfCallExpr(const CallExpr *CE) const;
+  std::vector<const NamedDecl *>
   resolveUsingValueDecl(const UnresolvedUsingValueDecl *UUVD) const;
   std::vector<const NamedDecl *>
   resolveDependentNameType(const DependentNameType *DNT) const;
@@ -87,6 +89,7 @@ class HeuristicResolver {
   // Try to heuristically resolve the type of a possibly-dependent expression
   // `E`.
   const Type *resolveExprToType(const Expr *E) const;
+  std::vector<const NamedDecl *> resolveExprToDecls(const Expr *E) const;
 
   // Given the type T of a dependent expression that appears of the LHS of a
   // "->", heuristically find a corresponding pointee type in whose scope we

clang-tools-extra/clangd/InlayHints.cpp

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "InlayHints.h"
+#include "HeuristicResolver.h"
 #include "ParsedAST.h"
 #include "support/Logger.h"
 #include "clang/AST/DeclarationName.h"
@@ -20,7 +21,8 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
 public:
   InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST)
       : Results(Results), AST(AST.getASTContext()),
-        MainFileID(AST.getSourceManager().getMainFileID()) {
+        MainFileID(AST.getSourceManager().getMainFileID()),
+        Resolver(AST.getHeuristicResolver()) {
     bool Invalid = false;
     llvm::StringRef Buf =
         AST.getSourceManager().getBufferData(MainFileID, &Invalid);
@@ -50,9 +52,18 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
     if (isa<CXXOperatorCallExpr>(E) || isa<UserDefinedLiteral>(E))
       return true;
 
-    processCall(E->getRParenLoc(),
-                dyn_cast_or_null<FunctionDecl>(E->getCalleeDecl()),
-                {E->getArgs(), E->getNumArgs()});
+    auto CalleeDecls = Resolver->resolveCalleeOfCallExpr(E);
+    if (CalleeDecls.size() != 1)
+      return true;
+    const FunctionDecl *Callee = nullptr;
+    if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecls[0]))
+      Callee = FD;
+    else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(CalleeDecls[0]))
+      Callee = FTD->getTemplatedDecl();
+    if (!Callee)
+      return true;
+
+    processCall(E->getRParenLoc(), Callee, {E->getArgs(), E->getNumArgs()});
     return true;
   }
 
@@ -266,6 +277,7 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
   ASTContext &AST;
   FileID MainFileID;
   StringRef MainFileBuf;
+  const HeuristicResolver *Resolver;
 };
 
 std::vector<InlayHint> inlayHints(ParsedAST &AST) {

clang-tools-extra/clangd/ParsedAST.cpp

@@ -16,6 +16,7 @@
 #include "Diagnostics.h"
 #include "FeatureModule.h"
 #include "Headers.h"
+#include "HeuristicResolver.h"
 #include "IncludeFixer.h"
 #include "Preamble.h"
 #include "SourceCode.h"

clang-tools-extra/clangd/ParsedAST.h

@@ -24,7 +24,6 @@
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "Headers.h"
-#include "HeuristicResolver.h"
 #include "Preamble.h"
 #include "index/CanonicalIncludes.h"
 #include "support/Path.h"
@@ -43,6 +42,7 @@
 
 namespace clang {
 namespace clangd {
+class HeuristicResolver;
 class SymbolIndex;
 
 /// Stores and provides access to parsed AST.

clang-tools-extra/clangd/SemanticHighlighting.cpp

@@ -8,6 +8,7 @@
 
 #include "SemanticHighlighting.h"
 #include "FindTarget.h"
+#include "HeuristicResolver.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "SourceCode.h"

clang-tools-extra/clangd/test/initialize-params.test

@@ -7,7 +7,6 @@
 # CHECK-NEXT:    "capabilities": {
 # CHECK-NEXT:      "astProvider": true,
 # CHECK-NEXT:      "callHierarchyProvider": true,
-# CHECK-NEXT:      "clangdInlayHintsProvider": true,
 # CHECK-NEXT:      "codeActionProvider": true,
 # CHECK-NEXT:      "compilationDatabase": {
 # CHECK-NEXT:        "automaticReload": true

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

@@ -308,6 +308,9 @@ opt<bool> FoldingRanges{
     Hidden,
 };
 
+opt<bool> InlayHints{"inlay-hints", cat(Features),
+                     desc("Enable preview of InlayHints feature"), init(false)};
+
 opt<unsigned> WorkerThreadsCount{
     "j",
     cat(Misc),
@@ -829,6 +832,7 @@ clangd accepts flags on the commandline, and in the CLANGD_FLAGS environment var
   }
   Opts.AsyncThreadsCount = WorkerThreadsCount;
   Opts.FoldingRanges = FoldingRanges;
+  Opts.InlayHints = InlayHints;
   Opts.MemoryCleanup = getMemoryCleanupFunction();
 
   Opts.CodeComplete.IncludeIneligibleResults = IncludeIneligibleResults;

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

@@ -244,19 +244,35 @@ TEST(ParameterHints, LeadingUnderscore) {
                        ExpectedHint{"p3: ", "p3"});
 }
 
-TEST(ParameterHints, DependentCall) {
-  // FIXME: This doesn't currently produce a hint but should.
+TEST(ParameterHints, DependentCalls) {
   assertParameterHints(R"cpp(
     template <typename T>
-    void foo(T param);
+    void nonmember(T par1);
+
+    template <typename T>
+    struct A {
+      void member(T par2);
+      static void static_member(T par3);
+    };
+
+    void overload(int anInt);
+    void overload(double aDouble);
 
     template <typename T>
     struct S {
-      void bar(T par) {
-        foo($param[[par]]);
+      void bar(A<T> a, T t) {
+        nonmember($par1[[t]]);
+        a.member($par2[[t]]);
+        // FIXME: This one does not work yet.
+        A<T>::static_member($par3[[t]]);
+        // We don't want to arbitrarily pick between
+        // "anInt" or "aDouble", so just show no hint.
+        overload(T{});
       }
     };
-  )cpp");
+  )cpp",
+                       ExpectedHint{"par1: ", "par1"},
+                       ExpectedHint{"par2: ", "par2"});
 }
 
 TEST(ParameterHints, VariadicFunction) {
@@ -362,4 +378,4 @@ TEST(ParameterHints, SetterFunctions) {
 
 } // namespace
 } // namespace clangd
-} // namespace clang
+} // namespace clang

clang/include/clang/AST/DeclCXX.h

@@ -2425,12 +2425,12 @@ class CXXConstructorDecl final
                      : ExplicitSpecKind::ResolvedFalse);
   }
 
-  enum TraillingAllocKind {
+  enum TrailingAllocKind {
     TAKInheritsConstructor = 1,
     TAKHasTailExplicit = 1 << 1,
   };
 
-  uint64_t getTraillingAllocKind() const {
+  uint64_t getTrailingAllocKind() const {
     return numTrailingObjects(OverloadToken<InheritedConstructor>()) |
            (numTrailingObjects(OverloadToken<ExplicitSpecifier>()) << 1);
   }

clang/include/clang/Basic/CodeGenOptions.def

@@ -172,7 +172,8 @@ CODEGENOPT(NoInlineLineTables, 1, 0) ///< Whether debug info should contain
 CODEGENOPT(StackClashProtector, 1, 0) ///< Set when -fstack-clash-protection is enabled.
 CODEGENOPT(NoImplicitFloat   , 1, 0) ///< Set when -mno-implicit-float is enabled.
 CODEGENOPT(NullPointerIsValid , 1, 0) ///< Assume Null pointer deference is defined.
-CODEGENOPT(CorrectlyRoundedDivSqrt, 1, 0) ///< -cl-fp32-correctly-rounded-divide-sqrt
+CODEGENOPT(OpenCLCorrectlyRoundedDivSqrt, 1, 0) ///< -cl-fp32-correctly-rounded-divide-sqrt
+CODEGENOPT(HIPCorrectlyRoundedDivSqrt, 1, 1) ///< -fno-hip-fp32-correctly-rounded-divide-sqrt
 CODEGENOPT(UniqueInternalLinkageNames, 1, 0) ///< Internal Linkage symbols get unique names.
 CODEGENOPT(SplitMachineFunctions, 1, 0) ///< Split machine functions using profile information.