[clangd] Define out-of-line initial apply logic

[kadircet]

Summary

Initial implementation for apply logic, replaces function body with a
semicolon in source location and copies the full function definition into target
location.

Will handle qualification of return type and function name in following patches
to keep the changes small.

[kadircet]

• Rebase

[hokein]

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

60

the function name doesn't reflect what it does, it doesn't move the function, it just returns the source code of the function, I'd call it some name like getFunctionSourceCode.

130

The FileName is not always absolute, getCorrespondingHeaderOrSource is expecting an absolute file path input.

132

could we use a better name, Source in the context here has two different meaning: 1) the corresponding .cc file 2) the source of moving function declaration (we called it Source);

Maybe call it CCFile?

170

maybe just const tooling::Replacement InsertFunctionDef(Contents, *InsertionOffset, 0, *FunDef);, which would save us a InsertLoc.

179

nit: I think CharSourceRange::getCharRange(Source->getBody()->getSourceRange()) is clearer.

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

1574

thinking more about this, if this function is inline, we will leave an unnecessary inline keyword after running the code action. No need to address it in the patch, just keep in mind.

can we add more tests? e.g. template functions.

[kadircet]

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

1574

added a fixme for inline stuff.

[kadircet]

• Address comments
• Handle template parameters when copying function and add tests

[hokein]

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

55

Could you confirm the code handle template specializations as well? I think getDescribedFunctionTemplate will return null when FD is a specialization, and we still miss the template list.

73

I think we could simplify the code like:

const auto* TargetFD = FD->getDescribedFunctionTemplate() ? FD->getDescribedFunctionTemplate(): FD;
auto CharRange = toHaleOpenFileRange(.., FD->getSourceRange());

131

should we use getCanonicalPath in the SourceCode.h?

158

nit: maybe put the code for calculating the insertion point to a separate function.

[kadircet]

• Address comments

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

55

added a unittest

[kadircet]

• Get rid of raw string literals inside macros

[hokein]

looks good.

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

51

this function seems trivial, I'd inline them into call sides for both define inline and outline.

[kadircet]

• Address comments
• Better handling for macros and tests

[merge_guards_bot]

Build result: FAILURE - Could not check out parent git hash "6a2d56e54fa4a2009787a605607b0df7fe16dd98". It was not found in the repository. Did you configure the "Parent Revision" in Phabricator properly? Trying to apply the patch to the master branch instead...

ERROR: arc patch failed with error code 1. Check build log for details.
Log files: console-log.txt, CMakeCache.txt

[thakis]

ApplyTest fails on Windows; probably the usual delayed template parsing thing: http://45.33.8.238/win/3368/step_7.txt

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

 //===--- DefineOutline.cpp ---------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "HeaderSourceSwitch.h"
 #include "Path.h"
 #include "Selection.h"
+#include "SourceCode.h"
 #include "refactor/Tweak.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Stmt.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Driver/Types.h"
+#include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/Support/Path.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 // Deduces the FunctionDecl from a selection. Requires either the function body
 // or the function decl to be selected. Returns null if none of the above
 // criteria is met.
 // FIXME: This is shared with define inline, move them to a common header once
 // we have a place for such.
 const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) {
   if (!SelNode)
     return nullptr;
   const ast_type_traits::DynTypedNode &AstNode = SelNode->ASTNode;
   if (const FunctionDecl *FD = AstNode.get<FunctionDecl>())
     return FD;
   if (AstNode.get<CompoundStmt>() &&
       SelNode->Selected == SelectionTree::Complete) {
     if (const SelectionTree::Node *P = SelNode->Parent)
       return P->ASTNode.get<FunctionDecl>();
   }
   return nullptr;
 }
 
+// Returns the begining location for a FunctionDecl. Returns location of
+// template keyword for templated functions.
+// FIXME: This is shared with define inline, move them to a common header once
+// we have a place for such.
+const SourceLocation getBeginLoc(const FunctionDecl *FD) {
+  // Include template parameter list.
+  if (auto *FTD = FD->getDescribedFunctionTemplate())
+    return FTD->getBeginLoc();
+  return FD->getBeginLoc();
+}
+
+llvm::Optional<Path> getSourceFile(llvm::StringRef FileName,
+                                   const Tweak::Selection &Sel) {
+  if (auto Source = getCorrespondingHeaderOrSource(
+          FileName,
+          &Sel.AST.getSourceManager().getFileManager().getVirtualFileSystem()))
+    return *Source;
+  return getCorrespondingHeaderOrSource(FileName, Sel.AST, Sel.Index);
+}
+
+// Creates a modified version of function definition that can be inserted at a
+// different location. Contains both function signature and body.
+llvm::Optional<llvm::StringRef> getFunctionSourceCode(const FunctionDecl *FD) {
+  auto &SM = FD->getASTContext().getSourceManager();
+  auto CharRange = toHalfOpenFileRange(SM, FD->getASTContext().getLangOpts(),
+                                       FD->getSourceRange());
+  if (!CharRange)
+    return llvm::None;
+  CharRange->setBegin(getBeginLoc(FD));
+
+  // FIXME: Qualify return type.
+  // FIXME: Qualify function name depending on the target context.
+  return toSourceCode(SM, *CharRange);
+}
+
 /// Moves definition of a function/method to an appropriate implementation file.
 ///
 /// Before:
 /// a.h
 ///   void foo() { return; }
 /// a.cc
 ///   #include "a.h"
 ///
bool prepare(const Selection &Sel) override {
 
     // Note that we don't check whether an implementation file exists or not in
     // the prepare, since performing disk IO on each prepare request might be
     // expensive.
     return true;
   }
 
   Expected<Effect> apply(const Selection &Sel) override {
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "Not implemented yet");
+    const SourceManager &SM = Sel.AST.getSourceManager();
+    llvm::StringRef FileName =
+        SM.getFileEntryForID(SM.getMainFileID())->tryGetRealPathName();
+
+    auto CCFile = getSourceFile(FileName, Sel);
+    if (!CCFile)
+      return llvm::createStringError(
+          llvm::inconvertibleErrorCode(),
+          "Couldn't find a suitable implementation file.");
+
+    auto &FS =
+        Sel.AST.getSourceManager().getFileManager().getVirtualFileSystem();
+    auto Buffer = FS.getBufferForFile(*CCFile);
+    // FIXME: Maybe we should consider creating the implementation file if it
+    // doesn't exist?
+    if (!Buffer)
+      return llvm::createStringError(Buffer.getError(),
+                                     Buffer.getError().message());
+    auto Contents = Buffer->get()->getBuffer();
+    auto Region =
+        getEligiblePoints(Contents, Source->getQualifiedNameAsString(),
+                          getFormatStyleForFile(*CCFile, Contents, &FS));
+
+    assert(!Region.EligiblePoints.empty());
+    // FIXME: This selection can be made smarter by looking at the definition
+    // locations for adjacent decls to Source. Unfortunately psudeo parsing in
+    // getEligibleRegions only knows about namespace begin/end events so we
+    // can't match function start/end positions yet.
+    auto InsertionPoint = Region.EligiblePoints.back();
+    auto InsertionOffset = positionToOffset(Contents, InsertionPoint);
+    if (!InsertionOffset)
+      return InsertionOffset.takeError();
+
+    auto FuncDef = getFunctionSourceCode(Source);
+    if (!FuncDef)
+      return llvm::createStringError(
+          llvm::inconvertibleErrorCode(),
+          "Couldn't get full source for function definition.");
+
+    SourceManagerForFile SMFF(*CCFile, Contents);
+    const tooling::Replacement InsertFunctionDef(*CCFile, *InsertionOffset, 0,
+                                                 *FuncDef);
+    auto Effect = Effect::mainFileEdit(
+        SMFF.get(), tooling::Replacements(InsertFunctionDef));
+    if (!Effect)
+      return Effect.takeError();
+
+    // FIXME: We should also get rid of inline qualifier.
+    const tooling::Replacement DeleteFuncBody(
+        Sel.AST.getSourceManager(),
+        CharSourceRange::getTokenRange(Source->getBody()->getSourceRange()),
+        ";");
+    auto HeaderFE = Effect::fileEdit(SM, SM.getMainFileID(),
+                                     tooling::Replacements(DeleteFuncBody));
+    if (!HeaderFE)
+      return HeaderFE.takeError();
+
+    Effect->ApplyEdits.try_emplace(HeaderFE->first,
+                                   std::move(HeaderFE->second));
+    return std::move(*Effect);
   }
 
 private:
   const FunctionDecl *Source = nullptr;
 };
 
 REGISTER_TWEAK(DefineOutline);
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

[[void [[Bar::[[b^a^z]]]]() [[{
       return;
     }]]]]
 
     [[void [[f^o^o]]() [[{
       return;
     }]]]])cpp");
 }
 
+TEST_F(DefineOutlineTest, ApplyTest) {
+  FileName = "Test.hpp";
+
+  // No implementation file.
+  EXPECT_EQ(apply("void fo^o() { return; }"),
+            "fail: Couldn't find a suitable implementation file.");
+
+  llvm::StringMap<std::string> EditedFiles;
+  ExtraFiles["Test.cpp"] = "";
+
+  EXPECT_EQ(apply("void fo^o() { return; }", &EditedFiles), "void foo() ;");
+  EXPECT_THAT(EditedFiles,
+              testing::ElementsAre(FileWithContents(testPath("Test.cpp"),
+                                                    "void foo() { return; }")));
+
+  EditedFiles.clear();
+  EXPECT_EQ(apply("template <typename T> void fo^o(T, T x) { return; }",
+                  &EditedFiles),
+            "template <typename T> void foo(T, T x) ;");
+  EXPECT_THAT(EditedFiles,
+              testing::ElementsAre(FileWithContents(
+                  testPath("Test.cpp"),
+                  "template <typename T> void foo(T, T x) { return; }")));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang