[clangd] Disable define out-of-line code action on templates

[hokein]

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

124–125

since we don't support template functions, I think this code can be removed.

392

is this inner if important? It seems that we could just return false.

[kadircet]

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

392

yeah I was considering redeclarations, but they should be handled in the previous if anyways.

[kadircet]

• Address comments

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

 llvm::Expected<std::string>
 getFunctionSourceAfterReplacements(const FunctionDecl *FD,
                                    const tooling::Replacements &Replacements) {
   const auto &SM = FD->getASTContext().getSourceManager();
   auto OrigFuncRange = toHalfOpenFileRange(
       SM, FD->getASTContext().getLangOpts(), FD->getSourceRange());
   if (!OrigFuncRange)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Couldn't get range for function.");
-  // Include template parameter list.
-  if (auto *FTD = FD->getDescribedFunctionTemplate())
-    OrigFuncRange->setBegin(FTD->getBeginLoc());
+  assert(!FD->getDescribedFunctionTemplate() &&
+         "Define out-of-line doesn't apply to function templates.");
 
   // Get new begin and end positions for the qualified function definition.
   unsigned FuncBegin = SM.getFileOffset(OrigFuncRange->getBegin());
   unsigned FuncEnd = Replacements.getShiftedCodePosition(
       SM.getFileOffset(OrigFuncRange->getEnd()));
 
   // Trim the result to function definition.
   auto QualifiedFunc = tooling::applyAllReplacements(
if (!isHeaderFile(Sel.AST->getSourceManager().getFilename(Sel.Cursor),
       return false;
 
     Source = getSelectedFunction(Sel.ASTSelection.commonAncestor());
     // Bail out if the selection is not a in-line function definition.
     if (!Source || !Source->doesThisDeclarationHaveABody() ||
         Source->isOutOfLine())
       return false;
 
+    // Bail out if this is a function template or specialization, as their
+    // definitions need to be visible in all including translation units.
+    if (auto *PT = Source->getDescribedFunctionTemplate())
+      return false;
+    if (auto *TSI = Source->getTemplateSpecializationInfo())
+      return false;
+
     // Bail out in templated classes, as it is hard to spell the class name, i.e
     // if the template parameter is unnamed.
     if (auto *MD = llvm::dyn_cast<CXXMethodDecl>(Source)) {
       if (MD->getParent()->isTemplated())
         return false;
     }
 
     // Note that we don't check whether an implementation file exists or not in

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

class Foo {
       F^oo(const Foo&) = delete;
     };)cpp");
 
   // Not available within templated classes, as it is hard to spell class name
   // out-of-line in such cases.
   EXPECT_UNAVAILABLE(R"cpp(
     template <typename> struct Foo { void fo^o(){} };
     )cpp");
+
+  // Not available on function templates and specializations, as definition must
+  // be visible to all translation units.
+  EXPECT_UNAVAILABLE(R"cpp(
+    template <typename> void fo^o() {};
+    template <> void fo^o<int>() {};
+  )cpp");
 }
 
 TEST_F(DefineOutlineTest, FailsWithoutSource) {
   FileName = "Test.hpp";
   llvm::StringRef Test = "void fo^o() { return; }";
   llvm::StringRef Expected =
       "fail: Couldn't find a suitable implementation file.";
   EXPECT_EQ(apply(Test), Expected);
struct {
     llvm::StringRef ExpectedSource;
   } Cases[] = {
       // Simple check
       {
           "void fo^o() { return; }",
           "void foo() ;",
           "void foo() { return; }",
       },
-      // Templated function.
-      {
-          "template <typename T> void fo^o(T, T x) { return; }",
-          "template <typename T> void foo(T, T x) ;",
-          "template <typename T> void foo(T, T x) { return; }",
-      },
-      {
-          "template <typename> void fo^o() { return; }",
-          "template <typename> void foo() ;",
-          "template <typename> void foo() { return; }",
-      },
-      // Template specialization.
-      {
-          R"cpp(
-            template <typename> void foo();
-            template <> void fo^o<int>() { return; })cpp",
-          R"cpp(
-            template <typename> void foo();
-            template <> void foo<int>() ;)cpp",
-          "template <> void foo<int>() { return; }",
-      },
       // Default args.
       {
           "void fo^o(int x, int y = 5, int = 2, int (*foo)(int) = nullptr) {}",
           "void foo(int x, int y = 5, int = 2, int (*foo)(int) = nullptr) ;",
           "void foo(int x, int y , int , int (*foo)(int) ) {}",
       },
       // Constructors
       {