[llvm-branch-commits] [clang-tools-extra] 5934a79 - [clangd] Split tweak tests into one file per tweak.

Adam Czachorowski via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Wed Dec 9 08:23:28 PST 2020


Author: Adam Czachorowski
Date: 2020-12-09T17:17:06+01:00
New Revision: 5934a79196b937806d8260aab7ae16e74219fad9

URL: https://github.com/llvm/llvm-project/commit/5934a79196b937806d8260aab7ae16e74219fad9
DIFF: https://github.com/llvm/llvm-project/commit/5934a79196b937806d8260aab7ae16e74219fad9.diff

LOG: [clangd] Split tweak tests into one file per tweak.

No changes to the tests themselves, other than some auto -> const auto
diagnostic fixes and formatting.

Differential Revision: https://reviews.llvm.org/D92939

Added: 
    clang-tools-extra/clangd/unittests/tweaks/AddUsingTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/DefineInlineTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/DefineOutlineTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/DumpASTTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/DumpRecordLayoutTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/DumpSymbolTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/ExpandAutoTypeTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/ExpandMacroTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/ExtractFunctionTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/ObjCLocalizeStringLiteralTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/PopulateSwitchTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/RawStringLiteralTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/ShowSelectionTreeTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/SwapIfBranchesTests.cpp
    clang-tools-extra/clangd/unittests/tweaks/TweakTesting.cpp
    clang-tools-extra/clangd/unittests/tweaks/TweakTesting.h
    clang-tools-extra/clangd/unittests/tweaks/TweakTests.cpp

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

Removed: 
    clang-tools-extra/clangd/unittests/TweakTesting.cpp
    clang-tools-extra/clangd/unittests/TweakTesting.h
    clang-tools-extra/clangd/unittests/TweakTests.cpp


################################################################################
diff  --git a/clang-tools-extra/clangd/unittests/CMakeLists.txt b/clang-tools-extra/clangd/unittests/CMakeLists.txt
index 72ce97ed31b6..10f10f200471 100644
--- a/clang-tools-extra/clangd/unittests/CMakeLists.txt
+++ b/clang-tools-extra/clangd/unittests/CMakeLists.txt
@@ -93,8 +93,6 @@ add_unittest(ClangdUnitTests ClangdTests
   TestTU.cpp
   TestWorkspace.cpp
   TypeHierarchyTests.cpp
-  TweakTests.cpp
-  TweakTesting.cpp
   URITests.cpp
   XRefsTests.cpp
   ${CMAKE_CURRENT_BINARY_DIR}/DecisionForestRuntimeTest.cpp
@@ -108,6 +106,26 @@ add_unittest(ClangdUnitTests ClangdTests
   support/TestTracer.cpp
   support/TraceTests.cpp
 
+  tweaks/AddUsingTests.cpp
+  tweaks/AnnotateHighlightingsTests.cpp
+  tweaks/DefineInlineTests.cpp
+  tweaks/DefineOutlineTests.cpp
+  tweaks/DumpASTTests.cpp
+  tweaks/DumpRecordLayoutTests.cpp
+  tweaks/DumpSymbolTests.cpp
+  tweaks/ExpandAutoTypeTests.cpp
+  tweaks/ExpandMacroTests.cpp
+  tweaks/ExtractFunctionTests.cpp
+  tweaks/ExtractVariableTests.cpp
+  tweaks/ObjCLocalizeStringLiteralTests.cpp
+  tweaks/PopulateSwitchTests.cpp
+  tweaks/RawStringLiteralTests.cpp
+  tweaks/RemoveUsingNamespaceTests.cpp
+  tweaks/ShowSelectionTreeTests.cpp
+  tweaks/SwapIfBranchesTests.cpp
+  tweaks/TweakTesting.cpp
+  tweaks/TweakTests.cpp
+
   ${REMOTE_TEST_SOURCES}
 
   $<TARGET_OBJECTS:obj.clangDaemonTweaks>

diff  --git a/clang-tools-extra/clangd/unittests/TweakTests.cpp b/clang-tools-extra/clangd/unittests/TweakTests.cpp
deleted file mode 100644
index 0dcf8feb786f..000000000000
--- a/clang-tools-extra/clangd/unittests/TweakTests.cpp
+++ /dev/null
@@ -1,3120 +0,0 @@
-//===-- TweakTests.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 "Annotations.h"
-#include "Config.h"
-#include "SourceCode.h"
-#include "TestFS.h"
-#include "TestTU.h"
-#include "TweakTesting.h"
-#include "refactor/Tweak.h"
-#include "clang/AST/Expr.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticIDs.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Basic/FileSystemOptions.h"
-#include "clang/Basic/LLVM.h"
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/Tooling/Core/Replacement.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/VirtualFileSystem.h"
-#include "llvm/Testing/Support/Error.h"
-#include "gmock/gmock-matchers.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include <cassert>
-#include <string>
-#include <utility>
-#include <vector>
-
-using ::testing::AllOf;
-using ::testing::ElementsAre;
-using ::testing::HasSubstr;
-using ::testing::StartsWith;
-
-namespace clang {
-namespace clangd {
-namespace {
-
-MATCHER_P2(FileWithContents, FileName, Contents, "") {
-  return arg.first() == FileName && arg.second == Contents;
-}
-
-TEST(FileEdits, AbsolutePath) {
-  auto RelPaths = {"a.h", "foo.cpp", "test/test.cpp"};
-
-  llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> MemFS(
-      new llvm::vfs::InMemoryFileSystem);
-  MemFS->setCurrentWorkingDirectory(testRoot());
-  for (auto Path : RelPaths)
-    MemFS->addFile(Path, 0, llvm::MemoryBuffer::getMemBuffer("", Path));
-  FileManager FM(FileSystemOptions(), MemFS);
-  DiagnosticsEngine DE(new DiagnosticIDs, new DiagnosticOptions);
-  SourceManager SM(DE, FM);
-
-  for (auto Path : RelPaths) {
-    auto FID = SM.createFileID(*FM.getFile(Path), SourceLocation(),
-                               clang::SrcMgr::C_User);
-    auto Res = Tweak::Effect::fileEdit(SM, FID, tooling::Replacements());
-    ASSERT_THAT_EXPECTED(Res, llvm::Succeeded());
-    EXPECT_EQ(Res->first, testPath(Path));
-  }
-}
-
-TWEAK_TEST(SwapIfBranches);
-TEST_F(SwapIfBranchesTest, Test) {
-  Context = Function;
-  EXPECT_EQ(apply("^if (true) {return;} else {(void)0;}"),
-            "if (true) {(void)0;} else {return;}");
-  EXPECT_EQ(apply("^if (/*error-ok*/) {return;} else {(void)0;}"),
-            "if (/*error-ok*/) {(void)0;} else {return;}")
-      << "broken condition";
-  EXPECT_AVAILABLE("^i^f^^(^t^r^u^e^) { return; } ^e^l^s^e^ { return; }");
-  EXPECT_UNAVAILABLE("if (true) {^return ^;^ } else { ^return^;^ }");
-  // Available in subexpressions of the condition;
-  EXPECT_THAT("if(2 + [[2]] + 2) { return; } else {return;}", isAvailable());
-  // But not as part of the branches.
-  EXPECT_THAT("if(2 + 2 + 2) { [[return]]; } else { return; }",
-              Not(isAvailable()));
-  // Range covers the "else" token, so available.
-  EXPECT_THAT("if(2 + 2 + 2) { return[[; } else {return;]]}", isAvailable());
-  // Not available in compound statements in condition.
-  EXPECT_THAT("if([]{return [[true]];}()) { return; } else { return; }",
-              Not(isAvailable()));
-  // Not available if both sides aren't braced.
-  EXPECT_THAT("^if (1) return; else { return; }", Not(isAvailable()));
-  // Only one if statement is supported!
-  EXPECT_THAT("[[if(1){}else{}if(2){}else{}]]", Not(isAvailable()));
-}
-
-TWEAK_TEST(RawStringLiteral);
-TEST_F(RawStringLiteralTest, Test) {
-  Context = Expression;
-  EXPECT_AVAILABLE(R"cpp(^"^f^o^o^\^n^")cpp");
-  EXPECT_AVAILABLE(R"cpp(R"(multi )" ^"token " "str\ning")cpp");
-  EXPECT_UNAVAILABLE(R"cpp(^"f^o^o^o")cpp"); // no chars need escaping
-  EXPECT_UNAVAILABLE(R"cpp(R"(multi )" ^"token " u8"str\ning")cpp"); // nonascii
-  EXPECT_UNAVAILABLE(R"cpp(^R^"^(^multi )" "token " "str\ning")cpp"); // raw
-  EXPECT_UNAVAILABLE(R"cpp(^"token\n" __FILE__)cpp"); // chunk is macro
-  EXPECT_UNAVAILABLE(R"cpp(^"a\r\n";)cpp");           // forbidden escape char
-
-  const char *Input = R"cpp(R"(multi
-token)" "\nst^ring\n" "literal")cpp";
-  const char *Output = R"cpp(R"(multi
-token
-string
-literal)")cpp";
-  EXPECT_EQ(apply(Input), Output);
-}
-
-TWEAK_TEST(ObjCLocalizeStringLiteral);
-TEST_F(ObjCLocalizeStringLiteralTest, Test) {
-  ExtraArgs.push_back("-x");
-  ExtraArgs.push_back("objective-c");
-
-  // Ensure the action can be initiated in the string literal.
-  EXPECT_AVAILABLE(R"(id x = ^[[@[[^"^t^est^"]]]];)");
-
-  // Ensure that the action can't be initiated in other places.
-  EXPECT_UNAVAILABLE(R"([[i^d ^[[x]] ^= @"test";^]])");
-
-  // Ensure that the action is not available for regular C strings.
-  EXPECT_UNAVAILABLE(R"(const char * x= "^test";)");
-
-  const char *Input = R"(id x = [[@"test"]];)";
-  const char *Output = R"(id x = NSLocalizedString(@"test", @"");)";
-  EXPECT_EQ(apply(Input), Output);
-}
-
-TWEAK_TEST(DumpAST);
-TEST_F(DumpASTTest, Test) {
-  EXPECT_AVAILABLE("^int f^oo() { re^turn 2 ^+ 2; }");
-  EXPECT_UNAVAILABLE("/*c^omment*/ int foo() { return 2 ^ + 2; }");
-  EXPECT_THAT(apply("int x = 2 ^+ 2;"),
-              AllOf(StartsWith("message:"), HasSubstr("BinaryOperator"),
-                    HasSubstr("'+'"), HasSubstr("|-IntegerLiteral"),
-                    HasSubstr("<col:9> 'int' 2\n`-IntegerLiteral"),
-                    HasSubstr("<col:13> 'int' 2")));
-}
-
-TWEAK_TEST(DumpSymbol);
-TEST_F(DumpSymbolTest, Test) {
-  std::string ID = R"("id":"CA2EBE44A1D76D2A")";
-  std::string USR = R"("usr":"c:@F at foo#")";
-  EXPECT_THAT(apply("void f^oo();"),
-              AllOf(StartsWith("message:"), testing::HasSubstr(ID),
-                    testing::HasSubstr(USR)));
-}
-
-TWEAK_TEST(ShowSelectionTree);
-TEST_F(ShowSelectionTreeTest, Test) {
-  EXPECT_AVAILABLE("^int f^oo() { re^turn 2 ^+ 2; }");
-  EXPECT_AVAILABLE("/*c^omment*/ int foo() { return 2 ^ + 2; }");
-
-  const char *Output = R"(message:
- TranslationUnitDecl 
-   VarDecl int x = fcall(2 + 2)
-    .CallExpr fcall(2 + 2)
-       ImplicitCastExpr fcall
-        .DeclRefExpr fcall
-      .BinaryOperator 2 + 2
-        *IntegerLiteral 2
-)";
-  EXPECT_EQ(apply("int fcall(int); int x = fca[[ll(2 +]]2);"), Output);
-
-  Output = R"(message:
- TranslationUnitDecl 
-   FunctionDecl void x()
-     CompoundStmt { …
-       ForStmt for (;;) …
-        *BreakStmt break;
-)";
-  EXPECT_EQ(apply("void x() { for (;;) br^eak; }"), Output);
-}
-
-TWEAK_TEST(DumpRecordLayout);
-TEST_F(DumpRecordLayoutTest, Test) {
-  EXPECT_AVAILABLE("^s^truct ^X ^{ int x; ^};");
-  EXPECT_THAT("struct X { int ^a; };", Not(isAvailable()));
-  EXPECT_THAT("struct ^X;", Not(isAvailable()));
-  EXPECT_THAT("template <typename T> struct ^X { T t; };", Not(isAvailable()));
-  EXPECT_THAT("enum ^X {};", Not(isAvailable()));
-
-  EXPECT_THAT(apply("struct ^X { int x; int y; };"),
-              AllOf(StartsWith("message:"), HasSubstr("0 |   int x")));
-}
-
-TWEAK_TEST(ExtractVariable);
-TEST_F(ExtractVariableTest, Test) {
-  const char *AvailableCases = R"cpp(
-    int xyz(int a = 1) {
-      struct T {
-        int bar(int a = 1);
-        int z;
-      } t;
-      // return statement
-      return [[[[t.b[[a]]r]](t.z)]];
-    }
-    void f() {
-      int a = [[5 +]] [[4 * [[[[xyz]]()]]]];
-      // multivariable initialization
-      if(1)
-        int x = [[1]], y = [[a + 1]], a = [[1]], z = a + 1;
-      // if without else
-      if([[1]])
-        a = [[1]] + 1;
-      // if with else
-      if(a < [[3]])
-        if(a == [[4]])
-          a = [[5]] + 1;
-        else
-          a = [[5]] + 1;
-      else if (a < [[4]])
-        a = [[4]] + 1;
-      else
-        a = [[5]] + 1;
-      // for loop
-      for(a = [[1]] + 1; a > [[[[3]] + [[4]]]]; a++)
-        a = [[2]] + 1;
-      // while
-      while(a < [[1]])
-        a = [[1]] + 1;
-      // do while
-      do
-        a = [[1]] + 1;
-      while(a < [[3]]);
-    }
-  )cpp";
-  EXPECT_AVAILABLE(AvailableCases);
-
-  ExtraArgs = {"-xc"};
-  const char *AvailableButC = R"cpp(
-    void foo() {
-      int x = [[1]];
-    })cpp";
-  EXPECT_UNAVAILABLE(AvailableButC);
-  ExtraArgs = {};
-
-  const char *NoCrashCases = R"cpp(
-    // error-ok: broken code, but shouldn't crash
-    template<typename T, typename ...Args>
-    struct Test<T, Args...> {
-    Test(const T &v) :val[[(^]]) {}
-      T val;
-    };
-  )cpp";
-  EXPECT_UNAVAILABLE(NoCrashCases);
-
-  const char *UnavailableCases = R"cpp(
-    int xyz(int a = [[1]]) {
-      struct T {
-        int bar(int a = [[1]]);
-        int z = [[1]];
-      } t;
-      return [[t]].bar([[[[t]].z]]);
-    }
-    void v() { return; }
-    // function default argument
-    void f(int b = [[1]]) {
-      // empty selection
-      int a = ^1 ^+ ^2;
-      // void expressions
-      auto i = new int, j = new int;
-      [[[[delete i]], delete j]];
-      [[v]]();
-      // if
-      if(1)
-        int x = 1, y = a + 1, a = 1, z = [[a + 1]];
-      if(int a = 1)
-        if([[a + 1]] == 4)
-          a = [[[[a]] +]] 1;
-      // for loop
-      for(int a = 1, b = 2, c = 3; a > [[b + c]]; [[a++]])
-        a = [[a + 1]];
-      // lambda
-      auto lamb = [&[[a]], &[[b]]](int r = [[1]]) {return 1;};
-      // assignment
-      xyz([[a = 5]]);
-      xyz([[a *= 5]]);
-      // Variable DeclRefExpr
-      a = [[b]];
-      a = [[xyz()]];
-      // statement expression
-      [[xyz()]];
-      while (a)
-        [[++a]];
-      // label statement
-      goto label;
-      label:
-        a = [[1]];
-    }
-  )cpp";
-  EXPECT_UNAVAILABLE(UnavailableCases);
-
-  // vector of pairs of input and output strings
-  const std::vector<std::pair<std::string, std::string>> InputOutputs = {
-      // extraction from variable declaration/assignment
-      {R"cpp(void varDecl() {
-                   int a = 5 * (4 + (3 [[- 1)]]);
-                 })cpp",
-       R"cpp(void varDecl() {
-                   auto dummy = (3 - 1); int a = 5 * (4 + dummy);
-                 })cpp"},
-      // FIXME: extraction from switch case
-      /*{R"cpp(void f(int a) {
-               if(1)
-                 while(a < 1)
-                   switch (1) {
-                       case 1:
-                         a = [[1 + 2]];
-                         break;
-                       default:
-                         break;
-                   }
-             })cpp",
-       R"cpp(void f(int a) {
-               auto dummy = 1 + 2; if(1)
-                 while(a < 1)
-                   switch (1) {
-                       case 1:
-                         a = dummy;
-                         break;
-                       default:
-                         break;
-                   }
-             })cpp"},*/
-      // Macros
-      {R"cpp(#define PLUS(x) x++
-                 void f(int a) {
-                   int y = PLUS([[1+a]]);
-                 })cpp",
-       /*FIXME: It should be extracted like this.
-        R"cpp(#define PLUS(x) x++
-              void f(int a) {
-                auto dummy = 1+a; int y = PLUS(dummy);
-              })cpp"},*/
-       R"cpp(#define PLUS(x) x++
-                 void f(int a) {
-                   auto dummy = PLUS(1+a); int y = dummy;
-                 })cpp"},
-      // ensure InsertionPoint isn't inside a macro
-      {R"cpp(#define LOOP(x) while (1) {a = x;}
-                 void f(int a) {
-                   if(1)
-                    LOOP(5 + [[3]])
-                 })cpp",
-       R"cpp(#define LOOP(x) while (1) {a = x;}
-                 void f(int a) {
-                   auto dummy = 3; if(1)
-                    LOOP(5 + dummy)
-                 })cpp"},
-      {R"cpp(#define LOOP(x) do {x;} while(1);
-                 void f(int a) {
-                   if(1)
-                    LOOP(5 + [[3]])
-                 })cpp",
-       R"cpp(#define LOOP(x) do {x;} while(1);
-                 void f(int a) {
-                   auto dummy = 3; if(1)
-                    LOOP(5 + dummy)
-                 })cpp"},
-      // attribute testing
-      {R"cpp(void f(int a) {
-                    [ [gsl::suppress("type")] ] for (;;) a = [[1]] + 1;
-                 })cpp",
-       R"cpp(void f(int a) {
-                    auto dummy = 1; [ [gsl::suppress("type")] ] for (;;) a = dummy + 1;
-                 })cpp"},
-      // MemberExpr
-      {R"cpp(class T {
-                   T f() {
-                     return [[T().f()]].f();
-                   }
-                 };)cpp",
-       R"cpp(class T {
-                   T f() {
-                     auto dummy = T().f(); return dummy.f();
-                   }
-                 };)cpp"},
-      // Function DeclRefExpr
-      {R"cpp(int f() {
-                   return [[f]]();
-                 })cpp",
-       R"cpp(int f() {
-                   auto dummy = f(); return dummy;
-                 })cpp"},
-      // FIXME: Wrong result for \[\[clang::uninitialized\]\] int b = [[1]];
-      // since the attr is inside the DeclStmt and the bounds of
-      // DeclStmt don't cover the attribute.
-
-      // Binary subexpressions
-      {R"cpp(void f() {
-                   int x = 1 + [[2 + 3 + 4]] + 5;
-                 })cpp",
-       R"cpp(void f() {
-                   auto dummy = 2 + 3 + 4; int x = 1 + dummy + 5;
-                 })cpp"},
-      {R"cpp(void f() {
-                   int x = [[1 + 2 + 3]] + 4 + 5;
-                 })cpp",
-       R"cpp(void f() {
-                   auto dummy = 1 + 2 + 3; int x = dummy + 4 + 5;
-                 })cpp"},
-      {R"cpp(void f() {
-                   int x = 1 + 2 + [[3 + 4 + 5]];
-                 })cpp",
-       R"cpp(void f() {
-                   auto dummy = 3 + 4 + 5; int x = 1 + 2 + dummy;
-                 })cpp"},
-      // Non-associative operations have no special support
-      {R"cpp(void f() {
-                   int x = 1 - [[2 - 3 - 4]] - 5;
-                 })cpp",
-       R"cpp(void f() {
-                   auto dummy = 1 - 2 - 3 - 4; int x = dummy - 5;
-                 })cpp"},
-      // A mix of associative operators isn't associative.
-      {R"cpp(void f() {
-                   int x = 0 + 1 * [[2 + 3]] * 4 + 5;
-                 })cpp",
-       R"cpp(void f() {
-                   auto dummy = 1 * 2 + 3 * 4; int x = 0 + dummy + 5;
-                 })cpp"},
-      // Overloaded operators are supported, we assume associativity
-      // as if they were built-in.
-      {R"cpp(struct S {
-                   S(int);
-                 };
-                 S operator+(S, S);
-
-                 void f() {
-                   S x = S(1) + [[S(2) + S(3) + S(4)]] + S(5);
-                 })cpp",
-       R"cpp(struct S {
-                   S(int);
-                 };
-                 S operator+(S, S);
-
-                 void f() {
-                   auto dummy = S(2) + S(3) + S(4); S x = S(1) + dummy + S(5);
-                 })cpp"},
-      // Don't try to analyze across macro boundaries
-      // FIXME: it'd be nice to do this someday (in a safe way)
-      {R"cpp(#define ECHO(X) X
-                 void f() {
-                   int x = 1 + [[ECHO(2 + 3) + 4]] + 5;
-                 })cpp",
-       R"cpp(#define ECHO(X) X
-                 void f() {
-                   auto dummy = 1 + ECHO(2 + 3) + 4; int x = dummy + 5;
-                 })cpp"},
-      {R"cpp(#define ECHO(X) X
-                 void f() {
-                   int x = 1 + [[ECHO(2) + ECHO(3) + 4]] + 5;
-                 })cpp",
-       R"cpp(#define ECHO(X) X
-                 void f() {
-                   auto dummy = 1 + ECHO(2) + ECHO(3) + 4; int x = dummy + 5;
-                 })cpp"},
-  };
-  for (const auto &IO : InputOutputs) {
-    EXPECT_EQ(IO.second, apply(IO.first)) << IO.first;
-  }
-}
-
-TWEAK_TEST(AnnotateHighlightings);
-TEST_F(AnnotateHighlightingsTest, Test) {
-  EXPECT_AVAILABLE("^vo^id^ ^f(^) {^}^"); // available everywhere.
-  EXPECT_AVAILABLE("[[int a; int b;]]");
-  EXPECT_EQ("void /* entity.name.function.cpp */f() {}", apply("void ^f() {}"));
-
-  EXPECT_EQ(apply("[[void f1(); void f2();]]"),
-            "void /* entity.name.function.cpp */f1(); "
-            "void /* entity.name.function.cpp */f2();");
-
-  EXPECT_EQ(apply("void f1(); void f2() {^}"),
-            "void f1(); "
-            "void /* entity.name.function.cpp */f2() {}");
-}
-
-TWEAK_TEST(ExpandMacro);
-TEST_F(ExpandMacroTest, Test) {
-  Header = R"cpp(
-    // error-ok: not real c++, just token manipulation
-    #define FOO 1 2 3
-    #define FUNC(X) X+X+X
-    #define EMPTY
-    #define EMPTY_FN(X)
-  )cpp";
-
-  // Available on macro names, not available anywhere else.
-  EXPECT_AVAILABLE("^F^O^O^ BAR ^F^O^O^");
-  EXPECT_AVAILABLE("^F^U^N^C^(1)");
-  EXPECT_UNAVAILABLE("^#^d^efine^ ^XY^Z 1 ^2 ^3^");
-  EXPECT_UNAVAILABLE("FOO ^B^A^R^ FOO ^");
-  EXPECT_UNAVAILABLE("FUNC(^1^)^");
-
-  // Works as expected on object-like macros.
-  EXPECT_EQ(apply("^FOO BAR FOO"), "1 2 3 BAR FOO");
-  EXPECT_EQ(apply("FOO BAR ^FOO"), "FOO BAR 1 2 3");
-  // And function-like macros.
-  EXPECT_EQ(apply("F^UNC(2)"), "2 + 2 + 2");
-
-  // Works on empty macros.
-  EXPECT_EQ(apply("int a ^EMPTY;"), "int a ;");
-  EXPECT_EQ(apply("int a ^EMPTY_FN(1 2 3);"), "int a ;");
-  EXPECT_EQ(apply("int a = 123 ^EMPTY EMPTY_FN(1);"),
-            "int a = 123  EMPTY_FN(1);");
-  EXPECT_EQ(apply("int a = 123 ^EMPTY_FN(1) EMPTY;"), "int a = 123  EMPTY;");
-  EXPECT_EQ(apply("int a = 123 EMPTY_FN(1) ^EMPTY;"),
-            "int a = 123 EMPTY_FN(1) ;");
-}
-
-TWEAK_TEST(ExpandAutoType);
-TEST_F(ExpandAutoTypeTest, Test) {
-
-  Header = R"cpp(
-    namespace ns {
-      struct Class {
-        struct Nested {};
-      };
-      void Func();
-    }
-    inline namespace inl_ns {
-      namespace {
-        struct Visible {};
-      }
-    }
-  )cpp";
-
-  EXPECT_AVAILABLE("^a^u^t^o^ i = 0;");
-  EXPECT_UNAVAILABLE("auto ^i^ ^=^ ^0^;^");
-
-  // check primitive type
-  EXPECT_EQ(apply("[[auto]] i = 0;"), "int i = 0;");
-  EXPECT_EQ(apply("au^to i = 0;"), "int i = 0;");
-  // check classes and namespaces
-  EXPECT_EQ(apply("^auto C = ns::Class::Nested();"),
-            "ns::Class::Nested C = ns::Class::Nested();");
-  // check that namespaces are shortened
-  EXPECT_EQ(apply("namespace ns { void f() { ^auto C = Class(); } }"),
-            "namespace ns { void f() { Class C = Class(); } }");
-  // undefined functions should not be replaced
-  EXPECT_THAT(apply("au^to x = doesnt_exist(); // error-ok"),
-              StartsWith("fail: Could not deduce type for 'auto' type"));
-  // function pointers should not be replaced
-  EXPECT_THAT(apply("au^to x = &ns::Func;"),
-              StartsWith("fail: Could not expand type of function pointer"));
-  // lambda types are not replaced
-  EXPECT_UNAVAILABLE("au^to x = []{};");
-  // inline namespaces
-  EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
-            "Visible x = inl_ns::Visible();");
-  // local class
-  EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
-            "namespace x { void y() { struct S{}; S z = S(); } }");
-  // replace array types
-  EXPECT_EQ(apply(R"cpp(au^to x = "test";)cpp"),
-            R"cpp(const char * x = "test";)cpp");
-
-  EXPECT_UNAVAILABLE("dec^ltype(au^to) x = 10;");
-  // expanding types in structured bindings is syntactically invalid.
-  EXPECT_UNAVAILABLE("const ^auto &[x,y] = (int[]){1,2};");
-
-  // FIXME: Auto-completion in a template requires disabling delayed template
-  // parsing.
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  // unknown types in a template should not be replaced
-  EXPECT_THAT(apply("template <typename T> void x() { ^auto y = T::z(); }"),
-              StartsWith("fail: Could not deduce type for 'auto' type"));
-}
-
-TWEAK_TEST(ExtractFunction);
-TEST_F(ExtractFunctionTest, FunctionTest) {
-  Context = Function;
-
-  // Root statements should have common parent.
-  EXPECT_EQ(apply("for(;;) [[1+2; 1+2;]]"), "unavailable");
-  // Expressions aren't extracted.
-  EXPECT_EQ(apply("int x = 0; [[x++;]]"), "unavailable");
-  // We don't support extraction from lambdas.
-  EXPECT_EQ(apply("auto lam = [](){ [[int x;]] }; "), "unavailable");
-  // Partial statements aren't extracted.
-  EXPECT_THAT(apply("int [[x = 0]];"), "unavailable");
-  // FIXME: Support hoisting.
-  EXPECT_THAT(apply(" [[int a = 5;]] a++; "), "unavailable");
-
-  // Ensure that end of Zone and Beginning of PostZone being adjacent doesn't
-  // lead to break being included in the extraction zone.
-  EXPECT_THAT(apply("for(;;) { [[int x;]]break; }"), HasSubstr("extracted"));
-  // FIXME: ExtractFunction should be unavailable inside loop construct
-  // initializer/condition.
-  EXPECT_THAT(apply(" for([[int i = 0;]];);"), HasSubstr("extracted"));
-  // Extract certain return
-  EXPECT_THAT(apply(" if(true) [[{ return; }]] "), HasSubstr("extracted"));
-  // Don't extract uncertain return
-  EXPECT_THAT(apply(" if(true) [[if (false) return;]] "),
-              StartsWith("unavailable"));
-  EXPECT_THAT(
-      apply("#define RETURN_IF_ERROR(x) if (x) return\nRETU^RN_IF_ERROR(4);"),
-      StartsWith("unavailable"));
-
-  FileName = "a.c";
-  EXPECT_THAT(apply(" for([[int i = 0;]];);"), HasSubstr("unavailable"));
-}
-
-TEST_F(ExtractFunctionTest, FileTest) {
-  // Check all parameters are in order
-  std::string ParameterCheckInput = R"cpp(
-struct Foo {
-  int x;
-};
-void f(int a) {
-  int b;
-  int *ptr = &a;
-  Foo foo;
-  [[a += foo.x + b;
-  *ptr++;]]
-})cpp";
-  std::string ParameterCheckOutput = R"cpp(
-struct Foo {
-  int x;
-};
-void extracted(int &a, int &b, int * &ptr, Foo &foo) {
-a += foo.x + b;
-  *ptr++;
-}
-void f(int a) {
-  int b;
-  int *ptr = &a;
-  Foo foo;
-  extracted(a, b, ptr, foo);
-})cpp";
-  EXPECT_EQ(apply(ParameterCheckInput), ParameterCheckOutput);
-
-  // Check const qualifier
-  std::string ConstCheckInput = R"cpp(
-void f(const int c) {
-  [[while(c) {}]]
-})cpp";
-  std::string ConstCheckOutput = R"cpp(
-void extracted(const int &c) {
-while(c) {}
-}
-void f(const int c) {
-  extracted(c);
-})cpp";
-  EXPECT_EQ(apply(ConstCheckInput), ConstCheckOutput);
-
-  // Don't extract when we need to make a function as a parameter.
-  EXPECT_THAT(apply("void f() { [[int a; f();]] }"), StartsWith("fail"));
-
-  // We don't extract from methods for now since they may involve multi-file
-  // edits
-  std::string MethodFailInput = R"cpp(
-    class T {
-      void f() {
-        [[int x;]]
-      }
-    };
-  )cpp";
-  EXPECT_EQ(apply(MethodFailInput), "unavailable");
-
-  // We don't extract from templated functions for now as templates are hard
-  // to deal with.
-  std::string TemplateFailInput = R"cpp(
-    template<typename T>
-    void f() {
-      [[int x;]]
-    }
-  )cpp";
-  EXPECT_EQ(apply(TemplateFailInput), "unavailable");
-
-  std::string MacroInput = R"cpp(
-    #define F(BODY) void f() { BODY }
-    F ([[int x = 0;]])
-  )cpp";
-  std::string MacroOutput = R"cpp(
-    #define F(BODY) void f() { BODY }
-    void extracted() {
-int x = 0;
-}
-F (extracted();)
-  )cpp";
-  EXPECT_EQ(apply(MacroInput), MacroOutput);
-
-  // Shouldn't crash.
-  EXPECT_EQ(apply("void f([[int a]]);"), "unavailable");
-  // Don't extract if we select the entire function body (CompoundStmt).
-  std::string CompoundFailInput = R"cpp(
-    void f() [[{
-      int a;
-    }]]
-  )cpp";
-  EXPECT_EQ(apply(CompoundFailInput), "unavailable");
-}
-
-TEST_F(ExtractFunctionTest, ControlFlow) {
-  Context = Function;
-  // We should be able to extract break/continue with a parent loop/switch.
-  EXPECT_THAT(apply(" [[for(;;) if(1) break;]] "), HasSubstr("extracted"));
-  EXPECT_THAT(apply(" for(;;) [[while(1) break;]] "), HasSubstr("extracted"));
-  EXPECT_THAT(apply(" [[switch(1) { break; }]]"), HasSubstr("extracted"));
-  EXPECT_THAT(apply(" [[while(1) switch(1) { continue; }]]"),
-              HasSubstr("extracted"));
-  // Don't extract break and continue without a loop/switch parent.
-  EXPECT_THAT(apply(" for(;;) [[if(1) continue;]] "), StartsWith("fail"));
-  EXPECT_THAT(apply(" while(1) [[if(1) break;]] "), StartsWith("fail"));
-  EXPECT_THAT(apply(" switch(1) { [[break;]] }"), StartsWith("fail"));
-  EXPECT_THAT(apply(" for(;;) { [[while(1) break; break;]] }"),
-              StartsWith("fail"));
-}
-
-TEST_F(ExtractFunctionTest, ExistingReturnStatement) {
-  Context = File;
-  const char *Before = R"cpp(
-    bool lucky(int N);
-    int getNum(bool Superstitious, int Min, int Max) {
-      if (Superstitious) [[{
-        for (int I = Min; I <= Max; ++I)
-          if (lucky(I))
-            return I;
-        return -1;
-      }]] else {
-        return (Min + Max) / 2;
-      }
-    }
-  )cpp";
-  // FIXME: min/max should be by value.
-  // FIXME: avoid emitting redundant braces
-  const char *After = R"cpp(
-    bool lucky(int N);
-    int extracted(int &Min, int &Max) {
-{
-        for (int I = Min; I <= Max; ++I)
-          if (lucky(I))
-            return I;
-        return -1;
-      }
-}
-int getNum(bool Superstitious, int Min, int Max) {
-      if (Superstitious) return extracted(Min, Max); else {
-        return (Min + Max) / 2;
-      }
-    }
-  )cpp";
-  EXPECT_EQ(apply(Before), After);
-}
-
-TWEAK_TEST(RemoveUsingNamespace);
-TEST_F(RemoveUsingNamespaceTest, All) {
-  std::pair<llvm::StringRef /*Input*/, llvm::StringRef /*Expected*/> Cases[] = {
-      {// Remove all occurrences of ns. Qualify only unqualified.
-       R"cpp(
-      namespace ns1 { struct vector {}; }
-      namespace ns2 { struct map {}; }
-      using namespace n^s1;
-      using namespace ns2;
-      using namespace ns1;
-      int main() {
-        ns1::vector v1;
-        vector v2;
-        map m1;
-      }
-    )cpp",
-       R"cpp(
-      namespace ns1 { struct vector {}; }
-      namespace ns2 { struct map {}; }
-      
-      using namespace ns2;
-      
-      int main() {
-        ns1::vector v1;
-        ns1::vector v2;
-        map m1;
-      }
-    )cpp"},
-      {// Ident to be qualified is a macro arg.
-       R"cpp(
-      #define DECLARE(x, y) x y
-      namespace ns { struct vector {}; }
-      using namespace n^s;
-      int main() {
-        DECLARE(ns::vector, v1);
-        DECLARE(vector, v2);
-      }
-    )cpp",
-       R"cpp(
-      #define DECLARE(x, y) x y
-      namespace ns { struct vector {}; }
-      
-      int main() {
-        DECLARE(ns::vector, v1);
-        DECLARE(ns::vector, v2);
-      }
-    )cpp"},
-      {// Nested namespace: Fully qualify ident from inner ns.
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      using namespace aa::b^b;
-      int main() {
-        map m;
-      }
-    )cpp",
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      
-      int main() {
-        aa::bb::map m;
-      }
-    )cpp"},
-      {// Nested namespace: Fully qualify ident from inner ns.
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      using namespace a^a;
-      int main() {
-        bb::map m;
-      }
-    )cpp",
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      
-      int main() {
-        aa::bb::map m;
-      }
-    )cpp"},
-      {// Typedef.
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      using namespace a^a;
-      typedef bb::map map;
-      int main() { map M; }
-    )cpp",
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      
-      typedef aa::bb::map map;
-      int main() { map M; }
-    )cpp"},
-      {// FIXME: Nested namespaces: Not aware of using ns decl of outer ns.
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      using name[[space aa::b]]b;
-      using namespace aa;
-      int main() {
-        map m;
-      }
-    )cpp",
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      
-      using namespace aa;
-      int main() {
-        aa::bb::map m;
-      }
-    )cpp"},
-      {// Does not qualify ident from inner namespace.
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      using namespace aa::bb;
-      using namespace a^a;
-      int main() {
-        map m;
-      }
-    )cpp",
-       R"cpp(
-      namespace aa { namespace bb { struct map {}; }}
-      using namespace aa::bb;
-      
-      int main() {
-        map m;
-      }
-    )cpp"},
-      {// Available only for top level namespace decl.
-       R"cpp(
-        namespace aa {
-          namespace bb { struct map {}; }
-          using namespace b^b;
-        }
-        int main() { aa::map m; }
-    )cpp",
-       "unavailable"},
-      {// FIXME: Unavailable for namespaces containing using-namespace decl.
-       R"cpp(
-      namespace aa {
-        namespace bb { struct map {}; }
-        using namespace bb;
-      }
-      using namespace a^a;
-      int main() {
-        map m;
-      }
-    )cpp",
-       "unavailable"},
-      {R"cpp(
-      namespace a::b { struct Foo {}; }
-      using namespace a;
-      using namespace a::[[b]];
-      using namespace b;
-      int main() { Foo F;}
-    )cpp",
-       R"cpp(
-      namespace a::b { struct Foo {}; }
-      using namespace a;
-      
-      
-      int main() { a::b::Foo F;}
-    )cpp"},
-      {R"cpp(
-      namespace a::b { struct Foo {}; }
-      using namespace a;
-      using namespace a::b;
-      using namespace [[b]];
-      int main() { Foo F;}
-    )cpp",
-       R"cpp(
-      namespace a::b { struct Foo {}; }
-      using namespace a;
-      
-      
-      int main() { b::Foo F;}
-    )cpp"},
-      {// Enumerators.
-       R"cpp(
-      namespace tokens {
-      enum Token {
-        comma, identifier, numeric
-      };
-      }
-      using namespace tok^ens;
-      int main() {
-        auto x = comma;
-      }
-    )cpp",
-       R"cpp(
-      namespace tokens {
-      enum Token {
-        comma, identifier, numeric
-      };
-      }
-      
-      int main() {
-        auto x = tokens::comma;
-      }
-    )cpp"},
-      {// inline namespaces.
-       R"cpp(
-      namespace std { inline namespace ns1 { inline namespace ns2 { struct vector {}; }}}
-      using namespace st^d;
-      int main() {
-        vector V;
-      }
-    )cpp",
-       R"cpp(
-      namespace std { inline namespace ns1 { inline namespace ns2 { struct vector {}; }}}
-      
-      int main() {
-        std::vector V;
-      }
-    )cpp"}};
-  for (auto C : Cases)
-    EXPECT_EQ(C.second, apply(C.first)) << C.first;
-}
-
-TWEAK_TEST(DefineInline);
-TEST_F(DefineInlineTest, TriggersOnFunctionDecl) {
-  // Basic check for function body and signature.
-  EXPECT_AVAILABLE(R"cpp(
-  class Bar {
-    void baz();
-  };
-
-  [[void [[Bar::[[b^a^z]]]]() [[{
-    return;
-  }]]]]
-
-  void foo();
-  [[void [[f^o^o]]() [[{
-    return;
-  }]]]]
-  )cpp");
-
-  EXPECT_UNAVAILABLE(R"cpp(
-  // Not a definition
-  vo^i[[d^ ^f]]^oo();
-
-  [[vo^id ]]foo[[()]] {[[
-    [[(void)(5+3);
-    return;]]
-  }]]
-
-  // Definition with no body.
-  class Bar { Bar() = def^ault; };
-  )cpp");
-}
-
-TEST_F(DefineInlineTest, NoForwardDecl) {
-  Header = "void bar();";
-  EXPECT_UNAVAILABLE(R"cpp(
-  void bar() {
-    return;
-  }
-  // FIXME: Generate a decl in the header.
-  void fo^o() {
-    return;
-  })cpp");
-}
-
-TEST_F(DefineInlineTest, ReferencedDecls) {
-  EXPECT_AVAILABLE(R"cpp(
-    void bar();
-    void foo(int test);
-
-    void fo^o(int baz) {
-      int x = 10;
-      bar();
-    })cpp");
-
-  // Internal symbol usage.
-  Header = "void foo(int test);";
-  EXPECT_UNAVAILABLE(R"cpp(
-    void bar();
-    void fo^o(int baz) {
-      int x = 10;
-      bar();
-    })cpp");
-
-  // Becomes available after making symbol visible.
-  Header = "void bar();" + Header;
-  EXPECT_AVAILABLE(R"cpp(
-    void fo^o(int baz) {
-      int x = 10;
-      bar();
-    })cpp");
-
-  // FIXME: Move declaration below bar to make it visible.
-  Header.clear();
-  EXPECT_UNAVAILABLE(R"cpp(
-    void foo();
-    void bar();
-
-    void fo^o() {
-      bar();
-    })cpp");
-
-  // Order doesn't matter within a class.
-  EXPECT_AVAILABLE(R"cpp(
-    class Bar {
-      void foo();
-      void bar();
-    };
-
-    void Bar::fo^o() {
-      bar();
-    })cpp");
-
-  // FIXME: Perform include insertion to make symbol visible.
-  ExtraFiles["a.h"] = "void bar();";
-  Header = "void foo(int test);";
-  EXPECT_UNAVAILABLE(R"cpp(
-    #include "a.h"
-    void fo^o(int baz) {
-      int x = 10;
-      bar();
-    })cpp");
-}
-
-TEST_F(DefineInlineTest, TemplateSpec) {
-  EXPECT_UNAVAILABLE(R"cpp(
-    template <typename T> void foo();
-    template<> void foo<char>();
-
-    template<> void f^oo<int>() {
-    })cpp");
-  EXPECT_UNAVAILABLE(R"cpp(
-    template <typename T> void foo();
-
-    template<> void f^oo<int>() {
-    })cpp");
-  EXPECT_UNAVAILABLE(R"cpp(
-    template <typename T> struct Foo { void foo(); };
-
-    template <typename T> void Foo<T>::f^oo() {
-    })cpp");
-  EXPECT_AVAILABLE(R"cpp(
-    template <typename T> void foo();
-    void bar();
-    template <> void foo<int>();
-
-    template<> void f^oo<int>() {
-      bar();
-    })cpp");
-  EXPECT_UNAVAILABLE(R"cpp(
-    namespace bar {
-      template <typename T> void f^oo() {}
-      template void foo<int>();
-    })cpp");
-}
-
-TEST_F(DefineInlineTest, CheckForCanonDecl) {
-  EXPECT_UNAVAILABLE(R"cpp(
-    void foo();
-
-    void bar() {}
-    void f^oo() {
-      // This bar normally refers to the definition just above, but it is not
-      // visible from the forward declaration of foo.
-      bar();
-    })cpp");
-  // Make it available with a forward decl.
-  EXPECT_AVAILABLE(R"cpp(
-    void bar();
-    void foo();
-
-    void bar() {}
-    void f^oo() {
-      bar();
-    })cpp");
-}
-
-TEST_F(DefineInlineTest, UsingShadowDecls) {
-  // Template body is not parsed until instantiation time on windows, which
-  // results in arbitrary failures as function body becomes NULL.
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  EXPECT_UNAVAILABLE(R"cpp(
-  namespace ns1 { void foo(int); }
-  namespace ns2 { void foo(int*); }
-  template <typename T>
-  void bar();
-
-  using ns1::foo;
-  using ns2::foo;
-
-  template <typename T>
-  void b^ar() {
-    foo(T());
-  })cpp");
-}
-
-TEST_F(DefineInlineTest, TransformNestedNamespaces) {
-  auto Test = R"cpp(
-    namespace a {
-      void bar();
-      namespace b {
-        void baz();
-        namespace c {
-          void aux();
-        }
-      }
-    }
-
-    void foo();
-    using namespace a;
-    using namespace b;
-    using namespace c;
-    void f^oo() {
-      bar();
-      a::bar();
-
-      baz();
-      b::baz();
-      a::b::baz();
-
-      aux();
-      c::aux();
-      b::c::aux();
-      a::b::c::aux();
-    })cpp";
-  auto Expected = R"cpp(
-    namespace a {
-      void bar();
-      namespace b {
-        void baz();
-        namespace c {
-          void aux();
-        }
-      }
-    }
-
-    void foo(){
-      a::bar();
-      a::bar();
-
-      a::b::baz();
-      a::b::baz();
-      a::b::baz();
-
-      a::b::c::aux();
-      a::b::c::aux();
-      a::b::c::aux();
-      a::b::c::aux();
-    }
-    using namespace a;
-    using namespace b;
-    using namespace c;
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformUsings) {
-  auto Test = R"cpp(
-    namespace a { namespace b { namespace c { void aux(); } } }
-
-    void foo();
-    void f^oo() {
-      using namespace a;
-      using namespace b;
-      using namespace c;
-      using c::aux;
-      namespace d = c;
-    })cpp";
-  auto Expected = R"cpp(
-    namespace a { namespace b { namespace c { void aux(); } } }
-
-    void foo(){
-      using namespace a;
-      using namespace a::b;
-      using namespace a::b::c;
-      using a::b::c::aux;
-      namespace d = a::b::c;
-    }
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformDecls) {
-  auto Test = R"cpp(
-    void foo();
-    void f^oo() {
-      class Foo {
-      public:
-        void foo();
-        int x;
-      };
-
-      enum En { Zero, One };
-      En x = Zero;
-
-      enum class EnClass { Zero, One };
-      EnClass y = EnClass::Zero;
-    })cpp";
-  auto Expected = R"cpp(
-    void foo(){
-      class Foo {
-      public:
-        void foo();
-        int x;
-      };
-
-      enum En { Zero, One };
-      En x = Zero;
-
-      enum class EnClass { Zero, One };
-      EnClass y = EnClass::Zero;
-    }
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformTemplDecls) {
-  auto Test = R"cpp(
-    namespace a {
-      template <typename T> class Bar {
-      public:
-        void bar();
-      };
-      template <typename T> T bar;
-      template <typename T> void aux() {}
-    }
-
-    void foo();
-
-    using namespace a;
-    void f^oo() {
-      bar<Bar<int>>.bar();
-      aux<Bar<int>>();
-    })cpp";
-  auto Expected = R"cpp(
-    namespace a {
-      template <typename T> class Bar {
-      public:
-        void bar();
-      };
-      template <typename T> T bar;
-      template <typename T> void aux() {}
-    }
-
-    void foo(){
-      a::bar<a::Bar<int>>.bar();
-      a::aux<a::Bar<int>>();
-    }
-
-    using namespace a;
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformMembers) {
-  auto Test = R"cpp(
-    class Foo {
-      void foo();
-    };
-
-    void Foo::f^oo() {
-      return;
-    })cpp";
-  auto Expected = R"cpp(
-    class Foo {
-      void foo(){
-      return;
-    }
-    };
-
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-
-  ExtraFiles["a.h"] = R"cpp(
-    class Foo {
-      void foo();
-    };)cpp";
-
-  llvm::StringMap<std::string> EditedFiles;
-  Test = R"cpp(
-    #include "a.h"
-    void Foo::f^oo() {
-      return;
-    })cpp";
-  Expected = R"cpp(
-    #include "a.h"
-    )cpp";
-  EXPECT_EQ(apply(Test, &EditedFiles), Expected);
-
-  Expected = R"cpp(
-    class Foo {
-      void foo(){
-      return;
-    }
-    };)cpp";
-  EXPECT_THAT(EditedFiles,
-              ElementsAre(FileWithContents(testPath("a.h"), Expected)));
-}
-
-TEST_F(DefineInlineTest, TransformDependentTypes) {
-  auto Test = R"cpp(
-    namespace a {
-      template <typename T> class Bar {};
-    }
-
-    template <typename T>
-    void foo();
-
-    using namespace a;
-    template <typename T>
-    void f^oo() {
-      Bar<T> B;
-      Bar<Bar<T>> q;
-    })cpp";
-  auto Expected = R"cpp(
-    namespace a {
-      template <typename T> class Bar {};
-    }
-
-    template <typename T>
-    void foo(){
-      a::Bar<T> B;
-      a::Bar<a::Bar<T>> q;
-    }
-
-    using namespace a;
-    )cpp";
-
-  // Template body is not parsed until instantiation time on windows, which
-  // results in arbitrary failures as function body becomes NULL.
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformFunctionTempls) {
-  // Check we select correct specialization decl.
-  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
-      {R"cpp(
-          template <typename T>
-          void foo(T p);
-
-          template <>
-          void foo<int>(int p);
-
-          template <>
-          void foo<char>(char p);
-
-          template <>
-          void fo^o<int>(int p) {
-            return;
-          })cpp",
-       R"cpp(
-          template <typename T>
-          void foo(T p);
-
-          template <>
-          void foo<int>(int p){
-            return;
-          }
-
-          template <>
-          void foo<char>(char p);
-
-          )cpp"},
-      {// Make sure we are not selecting the first specialization all the time.
-       R"cpp(
-          template <typename T>
-          void foo(T p);
-
-          template <>
-          void foo<int>(int p);
-
-          template <>
-          void foo<char>(char p);
-
-          template <>
-          void fo^o<char>(char p) {
-            return;
-          })cpp",
-       R"cpp(
-          template <typename T>
-          void foo(T p);
-
-          template <>
-          void foo<int>(int p);
-
-          template <>
-          void foo<char>(char p){
-            return;
-          }
-
-          )cpp"},
-      {R"cpp(
-          template <typename T>
-          void foo(T p);
-
-          template <>
-          void foo<int>(int p);
-
-          template <typename T>
-          void fo^o(T p) {
-            return;
-          })cpp",
-       R"cpp(
-          template <typename T>
-          void foo(T p){
-            return;
-          }
-
-          template <>
-          void foo<int>(int p);
-
-          )cpp"},
-  };
-  // Template body is not parsed until instantiation time on windows, which
-  // results in arbitrary failures as function body becomes NULL.
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  for (const auto &Case : Cases)
-    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
-}
-
-TEST_F(DefineInlineTest, TransformTypeLocs) {
-  auto Test = R"cpp(
-    namespace a {
-      template <typename T> class Bar {
-      public:
-        template <typename Q> class Baz {};
-      };
-      class Foo{};
-    }
-
-    void foo();
-
-    using namespace a;
-    void f^oo() {
-      Bar<int> B;
-      Foo foo;
-      a::Bar<Bar<int>>::Baz<Bar<int>> q;
-    })cpp";
-  auto Expected = R"cpp(
-    namespace a {
-      template <typename T> class Bar {
-      public:
-        template <typename Q> class Baz {};
-      };
-      class Foo{};
-    }
-
-    void foo(){
-      a::Bar<int> B;
-      a::Foo foo;
-      a::Bar<a::Bar<int>>::Baz<a::Bar<int>> q;
-    }
-
-    using namespace a;
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformDeclRefs) {
-  auto Test = R"cpp(
-    namespace a {
-      template <typename T> class Bar {
-      public:
-        void foo();
-        static void bar();
-        int x;
-        static int y;
-      };
-      void bar();
-      void test();
-    }
-
-    void foo();
-    using namespace a;
-    void f^oo() {
-      a::Bar<int> B;
-      B.foo();
-      a::bar();
-      Bar<Bar<int>>::bar();
-      a::Bar<int>::bar();
-      B.x = Bar<int>::y;
-      Bar<int>::y = 3;
-      bar();
-      a::test();
-    })cpp";
-  auto Expected = R"cpp(
-    namespace a {
-      template <typename T> class Bar {
-      public:
-        void foo();
-        static void bar();
-        int x;
-        static int y;
-      };
-      void bar();
-      void test();
-    }
-
-    void foo(){
-      a::Bar<int> B;
-      B.foo();
-      a::bar();
-      a::Bar<a::Bar<int>>::bar();
-      a::Bar<int>::bar();
-      B.x = a::Bar<int>::y;
-      a::Bar<int>::y = 3;
-      a::bar();
-      a::test();
-    }
-    using namespace a;
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, StaticMembers) {
-  auto Test = R"cpp(
-    namespace ns { class X { static void foo(); void bar(); }; }
-    void ns::X::b^ar() {
-      foo();
-    })cpp";
-  auto Expected = R"cpp(
-    namespace ns { class X { static void foo(); void bar(){
-      foo();
-    } }; }
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformParamNames) {
-  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
-      {R"cpp(
-        void foo(int, bool b, int T\
-est);
-        void ^foo(int f, bool x, int z) {})cpp",
-       R"cpp(
-        void foo(int f, bool x, int z){}
-        )cpp"},
-      {R"cpp(
-        #define PARAM int Z
-        void foo(PARAM);
-
-        void ^foo(int X) {})cpp",
-       "fail: Cant rename parameter inside macro body."},
-      {R"cpp(
-        #define TYPE int
-        #define PARAM TYPE Z
-        #define BODY(x) 5 * (x) + 2
-        template <int P>
-        void foo(PARAM, TYPE Q, TYPE, TYPE W = BODY(P));
-        template <int x>
-        void ^foo(int Z, int b, int c, int d) {})cpp",
-       R"cpp(
-        #define TYPE int
-        #define PARAM TYPE Z
-        #define BODY(x) 5 * (x) + 2
-        template <int x>
-        void foo(PARAM, TYPE b, TYPE c, TYPE d = BODY(x)){}
-        )cpp"},
-  };
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  for (const auto &Case : Cases)
-    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
-}
-
-TEST_F(DefineInlineTest, TransformTemplParamNames) {
-  auto Test = R"cpp(
-    struct Foo {
-      struct Bar {
-        template <class, class X,
-                  template<typename> class, template<typename> class Y,
-                  int, int Z>
-        void foo(X, Y<X>, int W = 5 * Z + 2);
-      };
-    };
-
-    template <class T, class U,
-              template<typename> class V, template<typename> class W,
-              int X, int Y>
-    void Foo::Bar::f^oo(U, W<U>, int Q) {})cpp";
-  auto Expected = R"cpp(
-    struct Foo {
-      struct Bar {
-        template <class T, class U,
-                  template<typename> class V, template<typename> class W,
-                  int X, int Y>
-        void foo(U, W<U>, int Q = 5 * Y + 2){}
-      };
-    };
-
-    )cpp";
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TransformInlineNamespaces) {
-  auto Test = R"cpp(
-    namespace a { inline namespace b { namespace { struct Foo{}; } } }
-    void foo();
-
-    using namespace a;
-    void ^foo() {Foo foo;})cpp";
-  auto Expected = R"cpp(
-    namespace a { inline namespace b { namespace { struct Foo{}; } } }
-    void foo(){a::Foo foo;}
-
-    using namespace a;
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected);
-}
-
-TEST_F(DefineInlineTest, TokensBeforeSemicolon) {
-  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
-      {R"cpp(
-          void foo()    /*Comment -_-*/ /*Com 2*/ ;
-          void fo^o() { return ; })cpp",
-       R"cpp(
-          void foo()    /*Comment -_-*/ /*Com 2*/ { return ; }
-          )cpp"},
-
-      {R"cpp(
-          void foo();
-          void fo^o() { return ; })cpp",
-       R"cpp(
-          void foo(){ return ; }
-          )cpp"},
-
-      {R"cpp(
-          #define SEMI ;
-          void foo() SEMI
-          void fo^o() { return ; })cpp",
-       "fail: Couldn't find semicolon for target declaration."},
-  };
-  for (const auto &Case : Cases)
-    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
-}
-
-TEST_F(DefineInlineTest, HandleMacros) {
-  EXPECT_UNAVAILABLE(R"cpp(
-    #define BODY { return; }
-    void foo();
-    void f^oo()BODY)cpp");
-
-  EXPECT_UNAVAILABLE(R"cpp(
-    #define BODY void foo(){ return; }
-    void foo();
-    [[BODY]])cpp");
-
-  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
-      // We don't qualify declarations coming from macros.
-      {R"cpp(
-          #define BODY Foo
-          namespace a { class Foo{}; }
-          void foo();
-          using namespace a;
-          void f^oo(){BODY();})cpp",
-       R"cpp(
-          #define BODY Foo
-          namespace a { class Foo{}; }
-          void foo(){BODY();}
-          using namespace a;
-          )cpp"},
-
-      // Macro is not visible at declaration location, but we proceed.
-      {R"cpp(
-          void foo();
-          #define BODY return;
-          void f^oo(){BODY})cpp",
-       R"cpp(
-          void foo(){BODY}
-          #define BODY return;
-          )cpp"},
-
-      {R"cpp(
-          #define TARGET void foo()
-          TARGET;
-          void f^oo(){ return; })cpp",
-       R"cpp(
-          #define TARGET void foo()
-          TARGET{ return; }
-          )cpp"},
-
-      {R"cpp(
-          #define TARGET foo
-          void TARGET();
-          void f^oo(){ return; })cpp",
-       R"cpp(
-          #define TARGET foo
-          void TARGET(){ return; }
-          )cpp"},
-  };
-  for (const auto &Case : Cases)
-    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
-}
-
-TEST_F(DefineInlineTest, DropCommonNameSpecifiers) {
-  struct {
-    llvm::StringRef Test;
-    llvm::StringRef Expected;
-  } Cases[] = {
-      {R"cpp(
-        namespace a { namespace b { void aux(); } }
-        namespace ns1 {
-          void foo();
-          namespace qq { void test(); }
-          namespace ns2 {
-            void bar();
-            namespace ns3 { void baz(); }
-          }
-        }
-
-        using namespace a;
-        using namespace a::b;
-        using namespace ns1::qq;
-        void ns1::ns2::ns3::b^az() {
-          foo();
-          bar();
-          baz();
-          ns1::ns2::ns3::baz();
-          aux();
-          test();
-        })cpp",
-       R"cpp(
-        namespace a { namespace b { void aux(); } }
-        namespace ns1 {
-          void foo();
-          namespace qq { void test(); }
-          namespace ns2 {
-            void bar();
-            namespace ns3 { void baz(){
-          foo();
-          bar();
-          baz();
-          ns1::ns2::ns3::baz();
-          a::b::aux();
-          qq::test();
-        } }
-          }
-        }
-
-        using namespace a;
-        using namespace a::b;
-        using namespace ns1::qq;
-        )cpp"},
-      {R"cpp(
-        namespace ns1 {
-          namespace qq { struct Foo { struct Bar {}; }; using B = Foo::Bar; }
-          namespace ns2 { void baz(); }
-        }
-
-        using namespace ns1::qq;
-        void ns1::ns2::b^az() { Foo f; B b; })cpp",
-       R"cpp(
-        namespace ns1 {
-          namespace qq { struct Foo { struct Bar {}; }; using B = Foo::Bar; }
-          namespace ns2 { void baz(){ qq::Foo f; qq::B b; } }
-        }
-
-        using namespace ns1::qq;
-        )cpp"},
-      {R"cpp(
-        namespace ns1 {
-          namespace qq {
-            template<class T> struct Foo { template <class U> struct Bar {}; };
-            template<class T, class U>
-            using B = typename Foo<T>::template Bar<U>;
-          }
-          namespace ns2 { void baz(); }
-        }
-
-        using namespace ns1::qq;
-        void ns1::ns2::b^az() { B<int, bool> b; })cpp",
-       R"cpp(
-        namespace ns1 {
-          namespace qq {
-            template<class T> struct Foo { template <class U> struct Bar {}; };
-            template<class T, class U>
-            using B = typename Foo<T>::template Bar<U>;
-          }
-          namespace ns2 { void baz(){ qq::B<int, bool> b; } }
-        }
-
-        using namespace ns1::qq;
-        )cpp"},
-  };
-  for (const auto &Case : Cases)
-    EXPECT_EQ(apply(Case.Test), Case.Expected) << Case.Test;
-}
-
-TEST_F(DefineInlineTest, QualifyWithUsingDirectives) {
-  llvm::StringRef Test = R"cpp(
-    namespace a {
-      void bar();
-      namespace b { struct Foo{}; void aux(); }
-      namespace c { void cux(); }
-    }
-    using namespace a;
-    using X = b::Foo;
-    void foo();
-
-    using namespace b;
-    using namespace c;
-    void ^foo() {
-      cux();
-      bar();
-      X x;
-      aux();
-      using namespace c;
-      // FIXME: The last reference to cux() in body of foo should not be
-      // qualified, since there is a using directive inside the function body.
-      cux();
-    })cpp";
-  llvm::StringRef Expected = R"cpp(
-    namespace a {
-      void bar();
-      namespace b { struct Foo{}; void aux(); }
-      namespace c { void cux(); }
-    }
-    using namespace a;
-    using X = b::Foo;
-    void foo(){
-      c::cux();
-      bar();
-      X x;
-      b::aux();
-      using namespace c;
-      // FIXME: The last reference to cux() in body of foo should not be
-      // qualified, since there is a using directive inside the function body.
-      c::cux();
-    }
-
-    using namespace b;
-    using namespace c;
-    )cpp";
-  EXPECT_EQ(apply(Test), Expected) << Test;
-}
-
-TEST_F(DefineInlineTest, AddInline) {
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-  llvm::StringMap<std::string> EditedFiles;
-  ExtraFiles["a.h"] = "void foo();";
-  apply(R"cpp(#include "a.h"
-              void fo^o() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                               testPath("a.h"), "inline void foo(){}")));
-
-  // Check we put inline before cv-qualifiers.
-  ExtraFiles["a.h"] = "const int foo();";
-  apply(R"cpp(#include "a.h"
-              const int fo^o() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                               testPath("a.h"), "inline const int foo(){}")));
-
-  // No double inline.
-  ExtraFiles["a.h"] = "inline void foo();";
-  apply(R"cpp(#include "a.h"
-              inline void fo^o() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                               testPath("a.h"), "inline void foo(){}")));
-
-  // Constexprs don't need "inline".
-  ExtraFiles["a.h"] = "constexpr void foo();";
-  apply(R"cpp(#include "a.h"
-              constexpr void fo^o() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                               testPath("a.h"), "constexpr void foo(){}")));
-
-  // Class members don't need "inline".
-  ExtraFiles["a.h"] = "struct Foo { void foo(); };";
-  apply(R"cpp(#include "a.h"
-              void Foo::fo^o() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles,
-              testing::ElementsAre(FileWithContents(
-                  testPath("a.h"), "struct Foo { void foo(){} };")));
-
-  // Function template doesn't need to be "inline"d.
-  ExtraFiles["a.h"] = "template <typename T> void foo();";
-  apply(R"cpp(#include "a.h"
-              template <typename T>
-              void fo^o() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles,
-              testing::ElementsAre(FileWithContents(
-                  testPath("a.h"), "template <typename T> void foo(){}")));
-
-  // Specializations needs to be marked "inline".
-  ExtraFiles["a.h"] = R"cpp(
-                            template <typename T> void foo();
-                            template <> void foo<int>();)cpp";
-  apply(R"cpp(#include "a.h"
-              template <>
-              void fo^o<int>() {})cpp",
-        &EditedFiles);
-  EXPECT_THAT(EditedFiles,
-              testing::ElementsAre(FileWithContents(testPath("a.h"),
-                                                    R"cpp(
-                            template <typename T> void foo();
-                            template <> inline void foo<int>(){})cpp")));
-}
-
-TWEAK_TEST(DefineOutline);
-TEST_F(DefineOutlineTest, TriggersOnFunctionDecl) {
-  FileName = "Test.cpp";
-  // Not available unless in a header file.
-  EXPECT_UNAVAILABLE(R"cpp(
-    [[void [[f^o^o]]() [[{
-      return;
-    }]]]])cpp");
-
-  FileName = "Test.hpp";
-  // Not available unless function name or fully body is selected.
-  EXPECT_UNAVAILABLE(R"cpp(
-    // Not a definition
-    vo^i[[d^ ^f]]^oo();
-
-    [[vo^id ]]foo[[()]] {[[
-      [[(void)(5+3);
-      return;]]
-    }]])cpp");
-
-  // Available even if there are no implementation files.
-  EXPECT_AVAILABLE(R"cpp(
-    [[void [[f^o^o]]() [[{
-      return;
-    }]]]])cpp");
-
-  // Not available for out-of-line methods.
-  EXPECT_UNAVAILABLE(R"cpp(
-    class Bar {
-      void baz();
-    };
-
-    [[void [[Bar::[[b^a^z]]]]() [[{
-      return;
-    }]]]])cpp");
-
-  // Basic check for function body and signature.
-  EXPECT_AVAILABLE(R"cpp(
-    class Bar {
-      [[void [[f^o^o^]]() [[{ return; }]]]]
-    };
-
-    void foo();
-    [[void [[f^o^o]]() [[{
-      return;
-    }]]]])cpp");
-
-  // Not available on defaulted/deleted members.
-  EXPECT_UNAVAILABLE(R"cpp(
-    class Foo {
-      Fo^o() = default;
-      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);
-}
-
-TEST_F(DefineOutlineTest, ApplyTest) {
-  llvm::StringMap<std::string> EditedFiles;
-  ExtraFiles["Test.cpp"] = "";
-  FileName = "Test.hpp";
-  // Template body is not parsed until instantiation time on windows, which
-  // results in arbitrary failures as function body becomes NULL.
-  ExtraArgs.push_back("-fno-delayed-template-parsing");
-
-  struct {
-    llvm::StringRef Test;
-    llvm::StringRef ExpectedHeader;
-    llvm::StringRef ExpectedSource;
-  } Cases[] = {
-      // Simple check
-      {
-          "void fo^o() { return; }",
-          "void foo() ;",
-          "void foo() { 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
-      {
-          R"cpp(
-            class Foo {public: Foo(); Foo(int);};
-            class Bar {
-              Ba^r() {}
-              Bar(int x) : f1(x) {}
-              Foo f1;
-              Foo f2 = 2;
-            };)cpp",
-          R"cpp(
-            class Foo {public: Foo(); Foo(int);};
-            class Bar {
-              Bar() ;
-              Bar(int x) : f1(x) {}
-              Foo f1;
-              Foo f2 = 2;
-            };)cpp",
-          "Bar::Bar() {}\n",
-      },
-      // Ctor with initializer.
-      {
-          R"cpp(
-            class Foo {public: Foo(); Foo(int);};
-            class Bar {
-              Bar() {}
-              B^ar(int x) : f1(x), f2(3) {}
-              Foo f1;
-              Foo f2 = 2;
-            };)cpp",
-          R"cpp(
-            class Foo {public: Foo(); Foo(int);};
-            class Bar {
-              Bar() {}
-              Bar(int x) ;
-              Foo f1;
-              Foo f2 = 2;
-            };)cpp",
-          "Bar::Bar(int x) : f1(x), f2(3) {}\n",
-      },
-      // Ctor initializer with attribute.
-      {
-          R"cpp(
-              class Foo {
-                F^oo(int z) __attribute__((weak)) : bar(2){}
-                int bar;
-              };)cpp",
-          R"cpp(
-              class Foo {
-                Foo(int z) __attribute__((weak)) ;
-                int bar;
-              };)cpp",
-          "Foo::Foo(int z) __attribute__((weak)) : bar(2){}\n",
-      },
-      // Virt specifiers.
-      {
-          R"cpp(
-            struct A {
-              virtual void f^oo() {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              virtual void foo() ;
-            };)cpp",
-          " void A::foo() {}\n",
-      },
-      {
-          R"cpp(
-            struct A {
-              virtual virtual void virtual f^oo() {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              virtual virtual void virtual foo() ;
-            };)cpp",
-          "  void  A::foo() {}\n",
-      },
-      {
-          R"cpp(
-            struct A {
-              virtual void foo() = 0;
-            };
-            struct B : A {
-              void fo^o() override {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              virtual void foo() = 0;
-            };
-            struct B : A {
-              void foo() override ;
-            };)cpp",
-          "void B::foo()  {}\n",
-      },
-      {
-          R"cpp(
-            struct A {
-              virtual void foo() = 0;
-            };
-            struct B : A {
-              void fo^o() final {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              virtual void foo() = 0;
-            };
-            struct B : A {
-              void foo() final ;
-            };)cpp",
-          "void B::foo()  {}\n",
-      },
-      {
-          R"cpp(
-            struct A {
-              virtual void foo() = 0;
-            };
-            struct B : A {
-              void fo^o() final override {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              virtual void foo() = 0;
-            };
-            struct B : A {
-              void foo() final override ;
-            };)cpp",
-          "void B::foo()   {}\n",
-      },
-      {
-          R"cpp(
-            struct A {
-              static void fo^o() {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              static void foo() ;
-            };)cpp",
-          " void A::foo() {}\n",
-      },
-      {
-          R"cpp(
-            struct A {
-              static static void fo^o() {}
-            };)cpp",
-          R"cpp(
-            struct A {
-              static static void foo() ;
-            };)cpp",
-          "  void A::foo() {}\n",
-      },
-  };
-  for (const auto &Case : Cases) {
-    SCOPED_TRACE(Case.Test);
-    EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
-    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                                 testPath("Test.cpp"), Case.ExpectedSource)));
-  }
-}
-
-TEST_F(DefineOutlineTest, HandleMacros) {
-  llvm::StringMap<std::string> EditedFiles;
-  ExtraFiles["Test.cpp"] = "";
-  FileName = "Test.hpp";
-  ExtraArgs.push_back("-DVIRTUAL=virtual");
-  ExtraArgs.push_back("-DOVER=override");
-
-  struct {
-    llvm::StringRef Test;
-    llvm::StringRef ExpectedHeader;
-    llvm::StringRef ExpectedSource;
-  } Cases[] = {
-      {R"cpp(
-          #define BODY { return; }
-          void f^oo()BODY)cpp",
-       R"cpp(
-          #define BODY { return; }
-          void foo();)cpp",
-       "void foo()BODY"},
-
-      {R"cpp(
-          #define BODY return;
-          void f^oo(){BODY})cpp",
-       R"cpp(
-          #define BODY return;
-          void foo();)cpp",
-       "void foo(){BODY}"},
-
-      {R"cpp(
-          #define TARGET void foo()
-          [[TARGET]]{ return; })cpp",
-       R"cpp(
-          #define TARGET void foo()
-          TARGET;)cpp",
-       "TARGET{ return; }"},
-
-      {R"cpp(
-          #define TARGET foo
-          void [[TARGET]](){ return; })cpp",
-       R"cpp(
-          #define TARGET foo
-          void TARGET();)cpp",
-       "void TARGET(){ return; }"},
-      {R"cpp(#define VIRT virtual
-          struct A {
-            VIRT void f^oo() {}
-          };)cpp",
-       R"cpp(#define VIRT virtual
-          struct A {
-            VIRT void foo() ;
-          };)cpp",
-       " void A::foo() {}\n"},
-      {R"cpp(
-          struct A {
-            VIRTUAL void f^oo() {}
-          };)cpp",
-       R"cpp(
-          struct A {
-            VIRTUAL void foo() ;
-          };)cpp",
-       " void A::foo() {}\n"},
-      {R"cpp(
-          struct A {
-            virtual void foo() = 0;
-          };
-          struct B : A {
-            void fo^o() OVER {}
-          };)cpp",
-       R"cpp(
-          struct A {
-            virtual void foo() = 0;
-          };
-          struct B : A {
-            void foo() OVER ;
-          };)cpp",
-       "void B::foo()  {}\n"},
-      {R"cpp(#define STUPID_MACRO(X) virtual
-          struct A {
-            STUPID_MACRO(sizeof sizeof int) void f^oo() {}
-          };)cpp",
-       R"cpp(#define STUPID_MACRO(X) virtual
-          struct A {
-            STUPID_MACRO(sizeof sizeof int) void foo() ;
-          };)cpp",
-       " void A::foo() {}\n"},
-      {R"cpp(#define STAT static
-          struct A {
-            STAT void f^oo() {}
-          };)cpp",
-       R"cpp(#define STAT static
-          struct A {
-            STAT void foo() ;
-          };)cpp",
-       " void A::foo() {}\n"},
-      {R"cpp(#define STUPID_MACRO(X) static
-          struct A {
-            STUPID_MACRO(sizeof sizeof int) void f^oo() {}
-          };)cpp",
-       R"cpp(#define STUPID_MACRO(X) static
-          struct A {
-            STUPID_MACRO(sizeof sizeof int) void foo() ;
-          };)cpp",
-       " void A::foo() {}\n"},
-  };
-  for (const auto &Case : Cases) {
-    SCOPED_TRACE(Case.Test);
-    EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
-    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                                 testPath("Test.cpp"), Case.ExpectedSource)));
-  }
-}
-
-TEST_F(DefineOutlineTest, QualifyReturnValue) {
-  FileName = "Test.hpp";
-  ExtraFiles["Test.cpp"] = "";
-
-  struct {
-    llvm::StringRef Test;
-    llvm::StringRef ExpectedHeader;
-    llvm::StringRef ExpectedSource;
-  } Cases[] = {
-      {R"cpp(
-        namespace a { class Foo{}; }
-        using namespace a;
-        Foo fo^o() { return {}; })cpp",
-       R"cpp(
-        namespace a { class Foo{}; }
-        using namespace a;
-        Foo foo() ;)cpp",
-       "a::Foo foo() { return {}; }"},
-      {R"cpp(
-        namespace a {
-          class Foo {
-            class Bar {};
-            Bar fo^o() { return {}; }
-          };
-        })cpp",
-       R"cpp(
-        namespace a {
-          class Foo {
-            class Bar {};
-            Bar foo() ;
-          };
-        })cpp",
-       "a::Foo::Bar a::Foo::foo() { return {}; }\n"},
-      {R"cpp(
-        class Foo {};
-        Foo fo^o() { return {}; })cpp",
-       R"cpp(
-        class Foo {};
-        Foo foo() ;)cpp",
-       "Foo foo() { return {}; }"},
-  };
-  llvm::StringMap<std::string> EditedFiles;
-  for (auto &Case : Cases) {
-    apply(Case.Test, &EditedFiles);
-    EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
-    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                                 testPath("Test.cpp"), Case.ExpectedSource)));
-  }
-}
-
-TEST_F(DefineOutlineTest, QualifyFunctionName) {
-  FileName = "Test.hpp";
-  struct {
-    llvm::StringRef TestHeader;
-    llvm::StringRef TestSource;
-    llvm::StringRef ExpectedHeader;
-    llvm::StringRef ExpectedSource;
-  } Cases[] = {
-      {
-          R"cpp(
-            namespace a {
-              namespace b {
-                class Foo {
-                  void fo^o() {}
-                };
-              }
-            })cpp",
-          "",
-          R"cpp(
-            namespace a {
-              namespace b {
-                class Foo {
-                  void foo() ;
-                };
-              }
-            })cpp",
-          "void a::b::Foo::foo() {}\n",
-      },
-      {
-          "namespace a { namespace b { void f^oo() {} } }",
-          "namespace a{}",
-          "namespace a { namespace b { void foo() ; } }",
-          "namespace a{void b::foo() {} }",
-      },
-      {
-          "namespace a { namespace b { void f^oo() {} } }",
-          "using namespace a;",
-          "namespace a { namespace b { void foo() ; } }",
-          // FIXME: Take using namespace directives in the source file into
-          // account. This can be spelled as b::foo instead.
-          "using namespace a;void a::b::foo() {} ",
-      },
-  };
-  llvm::StringMap<std::string> EditedFiles;
-  for (auto &Case : Cases) {
-    ExtraFiles["Test.cpp"] = std::string(Case.TestSource);
-    EXPECT_EQ(apply(Case.TestHeader, &EditedFiles), Case.ExpectedHeader);
-    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
-                                 testPath("Test.cpp"), Case.ExpectedSource)))
-        << Case.TestHeader;
-  }
-}
-
-TEST_F(DefineOutlineTest, FailsMacroSpecifier) {
-  FileName = "Test.hpp";
-  ExtraFiles["Test.cpp"] = "";
-  ExtraArgs.push_back("-DFINALOVER=final override");
-
-  std::pair<StringRef, StringRef> Cases[] = {
-      {
-          R"cpp(
-          #define VIRT virtual void
-          struct A {
-            VIRT fo^o() {}
-          };)cpp",
-          "fail: define outline: couldn't remove `virtual` keyword."},
-      {
-          R"cpp(
-          #define OVERFINAL final override
-          struct A {
-            virtual void foo() {}
-          };
-          struct B : A {
-            void fo^o() OVERFINAL {}
-          };)cpp",
-          "fail: define outline: Can't move out of line as function has a "
-          "macro `override` specifier.\ndefine outline: Can't move out of line "
-          "as function has a macro `final` specifier."},
-      {
-          R"cpp(
-          struct A {
-            virtual void foo() {}
-          };
-          struct B : A {
-            void fo^o() FINALOVER {}
-          };)cpp",
-          "fail: define outline: Can't move out of line as function has a "
-          "macro `override` specifier.\ndefine outline: Can't move out of line "
-          "as function has a macro `final` specifier."},
-  };
-  for (const auto &Case : Cases) {
-    EXPECT_EQ(apply(Case.first), Case.second);
-  }
-}
-
-TWEAK_TEST(AddUsing);
-TEST_F(AddUsingTest, Prepare) {
-  Config Cfg;
-  Cfg.Style.FullyQualifiedNamespaces.push_back("ban");
-  WithContextValue WithConfig(Config::Key, std::move(Cfg));
-
-  const std::string Header = R"cpp(
-#define NS(name) one::two::name
-namespace ban { void foo() {} }
-namespace banana { void foo() {} }
-namespace one {
-void oo() {}
-template<typename TT> class tt {};
-namespace two {
-enum ee {};
-void ff() {}
-class cc {
-public:
-  struct st {};
-  static void mm() {}
-  cc operator|(const cc& x) const { return x; }
-};
-}
-})cpp";
-
-  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^:^:^t^w^o^:^:^f^f(); }");
-  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^::^o^o(); }");
-  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^:^:^t^w^o^:^:^e^e E; }");
-  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^:^:^t^w^o:^:^c^c C; }");
-  EXPECT_UNAVAILABLE(Header +
-                     "void fun() { o^n^e^:^:^t^w^o^:^:^c^c^:^:^m^m(); }");
-  EXPECT_UNAVAILABLE(Header +
-                     "void fun() { o^n^e^:^:^t^w^o^:^:^c^c^:^:^s^t inst; }");
-  EXPECT_UNAVAILABLE(Header +
-                     "void fun() { o^n^e^:^:^t^w^o^:^:^c^c^:^:^s^t inst; }");
-  EXPECT_UNAVAILABLE(Header + "void fun() { N^S(c^c) inst; }");
-  // This used to crash. Ideally we would support this case, but for now we just
-  // test that we don't crash.
-  EXPECT_UNAVAILABLE(Header +
-                     "template<typename TT> using foo = one::tt<T^T>;");
-  // Test that we don't crash or misbehave on unnamed DeclRefExpr.
-  EXPECT_UNAVAILABLE(Header +
-                     "void fun() { one::two::cc() ^| one::two::cc(); }");
-  // Do not offer code action when operating on a banned namespace.
-  EXPECT_UNAVAILABLE(Header + "void fun() { ban::fo^o(); }");
-  EXPECT_UNAVAILABLE(Header + "void fun() { ::ban::fo^o(); }");
-  EXPECT_AVAILABLE(Header + "void fun() { banana::fo^o(); }");
-
-  // Do not offer code action on typo-corrections.
-  EXPECT_UNAVAILABLE(Header + "/*error-ok*/c^c C;");
-
-  // NestedNameSpecifier, but no namespace.
-  EXPECT_UNAVAILABLE(Header + "class Foo {}; class F^oo foo;");
-
-  // Check that we do not trigger in header files.
-  FileName = "test.h";
-  ExtraArgs.push_back("-xc++-header"); // .h file is treated a C by default.
-  EXPECT_UNAVAILABLE(Header + "void fun() { one::two::f^f(); }");
-  FileName = "test.hpp";
-  EXPECT_UNAVAILABLE(Header + "void fun() { one::two::f^f(); }");
-}
-
-TEST_F(AddUsingTest, Apply) {
-  FileName = "test.cpp";
-  struct {
-    llvm::StringRef TestSource;
-    llvm::StringRef ExpectedSource;
-  } Cases[]{{
-                // Function, no other using, namespace.
-                R"cpp(
-#include "test.hpp"
-namespace {
-void fun() {
-  ^o^n^e^:^:^t^w^o^:^:^f^f();
-}
-})cpp",
-                R"cpp(
-#include "test.hpp"
-namespace {using one::two::ff;
-
-void fun() {
-  ff();
-}
-})cpp",
-            },
-            // Type, no other using, namespace.
-            {
-                R"cpp(
-#include "test.hpp"
-namespace {
-void fun() {
-  ::on^e::t^wo::c^c inst;
-}
-})cpp",
-                R"cpp(
-#include "test.hpp"
-namespace {using ::one::two::cc;
-
-void fun() {
-  cc inst;
-}
-})cpp",
-            },
-            // Type, no other using, no namespace.
-            {
-                R"cpp(
-#include "test.hpp"
-
-void fun() {
-  on^e::t^wo::e^e inst;
-})cpp",
-                R"cpp(
-#include "test.hpp"
-
-using one::two::ee;
-
-void fun() {
-  ee inst;
-})cpp"},
-            // Function, other usings.
-            {
-                R"cpp(
-#include "test.hpp"
-
-using one::two::cc;
-using one::two::ee;
-
-namespace {
-void fun() {
-  one::two::f^f();
-}
-})cpp",
-                R"cpp(
-#include "test.hpp"
-
-using one::two::cc;
-using one::two::ff;using one::two::ee;
-
-namespace {
-void fun() {
-  ff();
-}
-})cpp",
-            },
-            // Function, other usings inside namespace.
-            {
-                R"cpp(
-#include "test.hpp"
-
-using one::two::cc;
-
-namespace {
-
-using one::two::ff;
-
-void fun() {
-  o^ne::o^o();
-}
-})cpp",
-                R"cpp(
-#include "test.hpp"
-
-using one::two::cc;
-
-namespace {
-
-using one::oo;using one::two::ff;
-
-void fun() {
-  oo();
-}
-})cpp"},
-            // Using comes after cursor.
-            {
-                R"cpp(
-#include "test.hpp"
-
-namespace {
-
-void fun() {
-  one::t^wo::ff();
-}
-
-using one::two::cc;
-
-})cpp",
-                R"cpp(
-#include "test.hpp"
-
-namespace {using one::two::ff;
-
-
-void fun() {
-  ff();
-}
-
-using one::two::cc;
-
-})cpp"},
-            // Pointer type.
-            {R"cpp(
-#include "test.hpp"
-
-void fun() {
-  one::two::c^c *p;
-})cpp",
-             R"cpp(
-#include "test.hpp"
-
-using one::two::cc;
-
-void fun() {
-  cc *p;
-})cpp"},
-            // Namespace declared via macro.
-            {R"cpp(
-#include "test.hpp"
-#define NS_BEGIN(name) namespace name {
-
-NS_BEGIN(foo)
-
-void fun() {
-  one::two::f^f();
-}
-})cpp",
-             R"cpp(
-#include "test.hpp"
-#define NS_BEGIN(name) namespace name {
-
-using one::two::ff;
-
-NS_BEGIN(foo)
-
-void fun() {
-  ff();
-}
-})cpp"},
-            // Inside macro argument.
-            {R"cpp(
-#include "test.hpp"
-#define CALL(name) name()
-
-void fun() {
-  CALL(one::t^wo::ff);
-})cpp",
-             R"cpp(
-#include "test.hpp"
-#define CALL(name) name()
-
-using one::two::ff;
-
-void fun() {
-  CALL(ff);
-})cpp"},
-            // Parent namespace != lexical parent namespace
-            {R"cpp(
-#include "test.hpp"
-namespace foo { void fun(); }
-
-void foo::fun() {
-  one::two::f^f();
-})cpp",
-             R"cpp(
-#include "test.hpp"
-using one::two::ff;
-
-namespace foo { void fun(); }
-
-void foo::fun() {
-  ff();
-})cpp"},
-            // If all other using are fully qualified, add ::
-            {R"cpp(
-#include "test.hpp"
-
-using ::one::two::cc;
-using ::one::two::ee;
-
-void fun() {
-  one::two::f^f();
-})cpp",
-             R"cpp(
-#include "test.hpp"
-
-using ::one::two::cc;
-using ::one::two::ff;using ::one::two::ee;
-
-void fun() {
-  ff();
-})cpp"},
-            // Make sure we don't add :: if it's already there
-            {R"cpp(
-#include "test.hpp"
-
-using ::one::two::cc;
-using ::one::two::ee;
-
-void fun() {
-  ::one::two::f^f();
-})cpp",
-             R"cpp(
-#include "test.hpp"
-
-using ::one::two::cc;
-using ::one::two::ff;using ::one::two::ee;
-
-void fun() {
-  ff();
-})cpp"},
-            // If even one using doesn't start with ::, do not add it
-            {R"cpp(
-#include "test.hpp"
-
-using ::one::two::cc;
-using one::two::ee;
-
-void fun() {
-  one::two::f^f();
-})cpp",
-             R"cpp(
-#include "test.hpp"
-
-using ::one::two::cc;
-using one::two::ff;using one::two::ee;
-
-void fun() {
-  ff();
-})cpp"},
-            // using alias; insert using for the spelled name.
-            {R"cpp(
-#include "test.hpp"
-
-void fun() {
-  one::u^u u;
-})cpp",
-             R"cpp(
-#include "test.hpp"
-
-using one::uu;
-
-void fun() {
-  uu u;
-})cpp"},
-            // using namespace.
-            {R"cpp(
-#include "test.hpp"
-using namespace one;
-namespace {
-two::c^c C;
-})cpp",
-             R"cpp(
-#include "test.hpp"
-using namespace one;
-namespace {using two::cc;
-
-cc C;
-})cpp"},
-            // Type defined in main file, make sure using is after that.
-            {R"cpp(
-namespace xx {
-  struct yy {};
-}
-
-x^x::yy X;
-)cpp",
-             R"cpp(
-namespace xx {
-  struct yy {};
-}
-
-using xx::yy;
-
-yy X;
-)cpp"},
-            // Type defined in main file via "using", insert after that.
-            {R"cpp(
-#include "test.hpp"
-
-namespace xx {
-  using yy = one::two::cc;
-}
-
-x^x::yy X;
-)cpp",
-             R"cpp(
-#include "test.hpp"
-
-namespace xx {
-  using yy = one::two::cc;
-}
-
-using xx::yy;
-
-yy X;
-)cpp"},
-            // Using must come after function definition.
-            {R"cpp(
-namespace xx {
-  void yy();
-}
-
-void fun() {
-  x^x::yy();
-}
-)cpp",
-             R"cpp(
-namespace xx {
-  void yy();
-}
-
-using xx::yy;
-
-void fun() {
-  yy();
-}
-)cpp"},
-            // Existing using with non-namespace part.
-            {R"cpp(
-#include "test.hpp"
-using one::two::ee::ee_one;
-one::t^wo::cc c;
-)cpp",
-             R"cpp(
-#include "test.hpp"
-using one::two::cc;using one::two::ee::ee_one;
-cc c;
-)cpp"}};
-  llvm::StringMap<std::string> EditedFiles;
-  for (const auto &Case : Cases) {
-    for (const auto &SubCase : expandCases(Case.TestSource)) {
-      ExtraFiles["test.hpp"] = R"cpp(
-namespace one {
-void oo() {}
-namespace two {
-enum ee {ee_one};
-void ff() {}
-class cc {
-public:
-  struct st { struct nested {}; };
-  static void mm() {}
-};
-}
-using uu = two::cc;
-})cpp";
-      EXPECT_EQ(apply(SubCase, &EditedFiles), Case.ExpectedSource);
-    }
-  }
-}
-
-TWEAK_TEST(PopulateSwitch);
-TEST_F(PopulateSwitchTest, Test) {
-  struct Case {
-    CodeContext Context;
-    llvm::StringRef TestSource;
-    llvm::StringRef ExpectedSource;
-  };
-
-  Case Cases[]{
-      {
-          // No enumerators
-          Function,
-          R""(enum Enum {}; ^switch ((Enum)0) {})"",
-          "unavailable",
-      },
-      {
-          // All enumerators already in switch (unscoped)
-          Function,
-          R""(enum Enum {A,B}; ^switch (A) {case A:break;case B:break;})"",
-          "unavailable",
-      },
-      {
-          // All enumerators already in switch (scoped)
-          Function,
-          R""(
-            enum class Enum {A,B};
-            ^switch (Enum::A) {case Enum::A:break;case Enum::B:break;}
-          )"",
-          "unavailable",
-      },
-      {
-          // Default case in switch
-          Function,
-          R""(
-            enum class Enum {A,B};
-            ^switch (Enum::A) {default:break;}
-          )"",
-          "unavailable",
-      },
-      {
-          // GNU range in switch
-          Function,
-          R""(
-            enum class Enum {A,B};
-            ^switch (Enum::A) {case Enum::A ... Enum::B:break;}
-          )"",
-          "unavailable",
-      },
-      {
-          // Value dependent case expression
-          File,
-          R""(
-            enum class Enum {A,B};
-            template<Enum Value>
-            void function() {
-                ^switch (Enum::A) {case Value:break;}
-            }
-          )"",
-          "unavailable",
-      },
-      {
-          // Body not CompoundStmt
-          Function,
-          R""(enum Enum {A}; ^switch (A);)"",
-          "unavailable",
-      },
-      {
-          // Selection on switch token
-          Function,
-          R""(enum Enum {A}; ^switch (A) {})"",
-          R""(enum Enum {A}; switch (A) {case A:break;})"",
-      },
-      {
-          // Selection on switch condition
-          Function,
-          R""(enum Enum {A}; switch (^A) {})"",
-          R""(enum Enum {A}; switch (A) {case A:break;})"",
-      },
-      {
-          // Selection in switch body
-          Function,
-          R""(enum Enum {A}; switch (A) {^})"",
-          R""(enum Enum {A}; switch (A) {case A:break;})"",
-      },
-      {
-          // Scoped enumeration
-          Function,
-          R""(enum class Enum {A}; ^switch (Enum::A) {})"",
-          R""(enum class Enum {A}; switch (Enum::A) {case Enum::A:break;})"",
-      },
-      {
-          // Scoped enumeration with multiple enumerators
-          Function,
-          R""(
-            enum class Enum {A,B};
-            ^switch (Enum::A) {}
-          )"",
-          R""(
-            enum class Enum {A,B};
-            switch (Enum::A) {case Enum::A:case Enum::B:break;}
-          )"",
-      },
-      {
-          // Only filling in missing enumerators (unscoped)
-          Function,
-          R""(
-            enum Enum {A,B,C};
-            ^switch (A) {case B:break;}
-          )"",
-          R""(
-            enum Enum {A,B,C};
-            switch (A) {case B:break;case A:case C:break;}
-          )"",
-      },
-      {
-          // Only filling in missing enumerators,
-          // even when using integer literals
-          Function,
-          R""(
-            enum Enum {A,B=1,C};
-            ^switch (A) {case 1:break;}
-          )"",
-          R""(
-            enum Enum {A,B=1,C};
-            switch (A) {case 1:break;case A:case C:break;}
-          )"",
-      },
-      {
-          // Only filling in missing enumerators (scoped)
-          Function,
-          R""(
-            enum class Enum {A,B,C};
-            ^switch (Enum::A)
-            {case Enum::B:break;}
-          )"",
-          R""(
-            enum class Enum {A,B,C};
-            switch (Enum::A)
-            {case Enum::B:break;case Enum::A:case Enum::C:break;}
-          )"",
-      },
-      {
-          // Scoped enumerations in namespace
-          File,
-          R""(
-            namespace ns { enum class Enum {A}; }
-            void function() { ^switch (ns::Enum::A) {} }
-          )"",
-          R""(
-            namespace ns { enum class Enum {A}; }
-            void function() { switch (ns::Enum::A) {case ns::Enum::A:break;} }
-          )"",
-      },
-      {
-          // Unscoped enumerations in namespace
-          File,
-          R""(
-            namespace ns { enum Enum {A}; }
-            void function() { ^switch (ns::A) {} }
-          )"",
-          R""(
-            namespace ns { enum Enum {A}; }
-            void function() { switch (ns::A) {case ns::A:break;} }
-          )"",
-      },
-      {
-          // Duplicated constant names
-          Function,
-          R""(enum Enum {A,B,b=B}; ^switch (A) {})"",
-          R""(enum Enum {A,B,b=B}; switch (A) {case A:case B:break;})"",
-      },
-      {
-          // Duplicated constant names all in switch
-          Function,
-          R""(enum Enum {A,B,b=B}; ^switch (A) {case A:case B:break;})"",
-          "unavailable",
-      },
-      {
-          // Enum is dependent type
-          File,
-          R""(template<typename T> void f() {enum Enum {A}; ^switch (A) {}})"",
-          "unavailable",
-      },
-  };
-
-  for (const auto &Case : Cases) {
-    Context = Case.Context;
-    EXPECT_EQ(apply(Case.TestSource), Case.ExpectedSource);
-  }
-}
-
-} // namespace
-} // namespace clangd
-} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/AddUsingTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/AddUsingTests.cpp
new file mode 100644
index 000000000000..c0c66dbc14d7
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/AddUsingTests.cpp
@@ -0,0 +1,472 @@
+//===-- AddUsingTests.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 "Config.h"
+#include "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(AddUsing);
+
+TEST_F(AddUsingTest, Prepare) {
+  Config Cfg;
+  Cfg.Style.FullyQualifiedNamespaces.push_back("ban");
+  WithContextValue WithConfig(Config::Key, std::move(Cfg));
+
+  const std::string Header = R"cpp(
+#define NS(name) one::two::name
+namespace ban { void foo() {} }
+namespace banana { void foo() {} }
+namespace one {
+void oo() {}
+template<typename TT> class tt {};
+namespace two {
+enum ee {};
+void ff() {}
+class cc {
+public:
+  struct st {};
+  static void mm() {}
+  cc operator|(const cc& x) const { return x; }
+};
+}
+})cpp";
+
+  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^:^:^t^w^o^:^:^f^f(); }");
+  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^::^o^o(); }");
+  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^:^:^t^w^o^:^:^e^e E; }");
+  EXPECT_AVAILABLE(Header + "void fun() { o^n^e^:^:^t^w^o:^:^c^c C; }");
+  EXPECT_UNAVAILABLE(Header +
+                     "void fun() { o^n^e^:^:^t^w^o^:^:^c^c^:^:^m^m(); }");
+  EXPECT_UNAVAILABLE(Header +
+                     "void fun() { o^n^e^:^:^t^w^o^:^:^c^c^:^:^s^t inst; }");
+  EXPECT_UNAVAILABLE(Header +
+                     "void fun() { o^n^e^:^:^t^w^o^:^:^c^c^:^:^s^t inst; }");
+  EXPECT_UNAVAILABLE(Header + "void fun() { N^S(c^c) inst; }");
+  // This used to crash. Ideally we would support this case, but for now we just
+  // test that we don't crash.
+  EXPECT_UNAVAILABLE(Header +
+                     "template<typename TT> using foo = one::tt<T^T>;");
+  // Test that we don't crash or misbehave on unnamed DeclRefExpr.
+  EXPECT_UNAVAILABLE(Header +
+                     "void fun() { one::two::cc() ^| one::two::cc(); }");
+  // Do not offer code action when operating on a banned namespace.
+  EXPECT_UNAVAILABLE(Header + "void fun() { ban::fo^o(); }");
+  EXPECT_UNAVAILABLE(Header + "void fun() { ::ban::fo^o(); }");
+  EXPECT_AVAILABLE(Header + "void fun() { banana::fo^o(); }");
+
+  // Do not offer code action on typo-corrections.
+  EXPECT_UNAVAILABLE(Header + "/*error-ok*/c^c C;");
+
+  // NestedNameSpecifier, but no namespace.
+  EXPECT_UNAVAILABLE(Header + "class Foo {}; class F^oo foo;");
+
+  // Check that we do not trigger in header files.
+  FileName = "test.h";
+  ExtraArgs.push_back("-xc++-header"); // .h file is treated a C by default.
+  EXPECT_UNAVAILABLE(Header + "void fun() { one::two::f^f(); }");
+  FileName = "test.hpp";
+  EXPECT_UNAVAILABLE(Header + "void fun() { one::two::f^f(); }");
+}
+
+TEST_F(AddUsingTest, Apply) {
+  FileName = "test.cpp";
+  struct {
+    llvm::StringRef TestSource;
+    llvm::StringRef ExpectedSource;
+  } Cases[]{{
+                // Function, no other using, namespace.
+                R"cpp(
+#include "test.hpp"
+namespace {
+void fun() {
+  ^o^n^e^:^:^t^w^o^:^:^f^f();
+}
+})cpp",
+                R"cpp(
+#include "test.hpp"
+namespace {using one::two::ff;
+
+void fun() {
+  ff();
+}
+})cpp",
+            },
+            // Type, no other using, namespace.
+            {
+                R"cpp(
+#include "test.hpp"
+namespace {
+void fun() {
+  ::on^e::t^wo::c^c inst;
+}
+})cpp",
+                R"cpp(
+#include "test.hpp"
+namespace {using ::one::two::cc;
+
+void fun() {
+  cc inst;
+}
+})cpp",
+            },
+            // Type, no other using, no namespace.
+            {
+                R"cpp(
+#include "test.hpp"
+
+void fun() {
+  on^e::t^wo::e^e inst;
+})cpp",
+                R"cpp(
+#include "test.hpp"
+
+using one::two::ee;
+
+void fun() {
+  ee inst;
+})cpp"},
+            // Function, other usings.
+            {
+                R"cpp(
+#include "test.hpp"
+
+using one::two::cc;
+using one::two::ee;
+
+namespace {
+void fun() {
+  one::two::f^f();
+}
+})cpp",
+                R"cpp(
+#include "test.hpp"
+
+using one::two::cc;
+using one::two::ff;using one::two::ee;
+
+namespace {
+void fun() {
+  ff();
+}
+})cpp",
+            },
+            // Function, other usings inside namespace.
+            {
+                R"cpp(
+#include "test.hpp"
+
+using one::two::cc;
+
+namespace {
+
+using one::two::ff;
+
+void fun() {
+  o^ne::o^o();
+}
+})cpp",
+                R"cpp(
+#include "test.hpp"
+
+using one::two::cc;
+
+namespace {
+
+using one::oo;using one::two::ff;
+
+void fun() {
+  oo();
+}
+})cpp"},
+            // Using comes after cursor.
+            {
+                R"cpp(
+#include "test.hpp"
+
+namespace {
+
+void fun() {
+  one::t^wo::ff();
+}
+
+using one::two::cc;
+
+})cpp",
+                R"cpp(
+#include "test.hpp"
+
+namespace {using one::two::ff;
+
+
+void fun() {
+  ff();
+}
+
+using one::two::cc;
+
+})cpp"},
+            // Pointer type.
+            {R"cpp(
+#include "test.hpp"
+
+void fun() {
+  one::two::c^c *p;
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using one::two::cc;
+
+void fun() {
+  cc *p;
+})cpp"},
+            // Namespace declared via macro.
+            {R"cpp(
+#include "test.hpp"
+#define NS_BEGIN(name) namespace name {
+
+NS_BEGIN(foo)
+
+void fun() {
+  one::two::f^f();
+}
+})cpp",
+             R"cpp(
+#include "test.hpp"
+#define NS_BEGIN(name) namespace name {
+
+using one::two::ff;
+
+NS_BEGIN(foo)
+
+void fun() {
+  ff();
+}
+})cpp"},
+            // Inside macro argument.
+            {R"cpp(
+#include "test.hpp"
+#define CALL(name) name()
+
+void fun() {
+  CALL(one::t^wo::ff);
+})cpp",
+             R"cpp(
+#include "test.hpp"
+#define CALL(name) name()
+
+using one::two::ff;
+
+void fun() {
+  CALL(ff);
+})cpp"},
+            // Parent namespace != lexical parent namespace
+            {R"cpp(
+#include "test.hpp"
+namespace foo { void fun(); }
+
+void foo::fun() {
+  one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+using one::two::ff;
+
+namespace foo { void fun(); }
+
+void foo::fun() {
+  ff();
+})cpp"},
+            // If all other using are fully qualified, add ::
+            {R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ee;
+
+void fun() {
+  one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ff;using ::one::two::ee;
+
+void fun() {
+  ff();
+})cpp"},
+            // Make sure we don't add :: if it's already there
+            {R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ee;
+
+void fun() {
+  ::one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using ::one::two::ff;using ::one::two::ee;
+
+void fun() {
+  ff();
+})cpp"},
+            // If even one using doesn't start with ::, do not add it
+            {R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using one::two::ee;
+
+void fun() {
+  one::two::f^f();
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using ::one::two::cc;
+using one::two::ff;using one::two::ee;
+
+void fun() {
+  ff();
+})cpp"},
+            // using alias; insert using for the spelled name.
+            {R"cpp(
+#include "test.hpp"
+
+void fun() {
+  one::u^u u;
+})cpp",
+             R"cpp(
+#include "test.hpp"
+
+using one::uu;
+
+void fun() {
+  uu u;
+})cpp"},
+            // using namespace.
+            {R"cpp(
+#include "test.hpp"
+using namespace one;
+namespace {
+two::c^c C;
+})cpp",
+             R"cpp(
+#include "test.hpp"
+using namespace one;
+namespace {using two::cc;
+
+cc C;
+})cpp"},
+            // Type defined in main file, make sure using is after that.
+            {R"cpp(
+namespace xx {
+  struct yy {};
+}
+
+x^x::yy X;
+)cpp",
+             R"cpp(
+namespace xx {
+  struct yy {};
+}
+
+using xx::yy;
+
+yy X;
+)cpp"},
+            // Type defined in main file via "using", insert after that.
+            {R"cpp(
+#include "test.hpp"
+
+namespace xx {
+  using yy = one::two::cc;
+}
+
+x^x::yy X;
+)cpp",
+             R"cpp(
+#include "test.hpp"
+
+namespace xx {
+  using yy = one::two::cc;
+}
+
+using xx::yy;
+
+yy X;
+)cpp"},
+            // Using must come after function definition.
+            {R"cpp(
+namespace xx {
+  void yy();
+}
+
+void fun() {
+  x^x::yy();
+}
+)cpp",
+             R"cpp(
+namespace xx {
+  void yy();
+}
+
+using xx::yy;
+
+void fun() {
+  yy();
+}
+)cpp"},
+            // Existing using with non-namespace part.
+            {R"cpp(
+#include "test.hpp"
+using one::two::ee::ee_one;
+one::t^wo::cc c;
+)cpp",
+             R"cpp(
+#include "test.hpp"
+using one::two::cc;using one::two::ee::ee_one;
+cc c;
+)cpp"}};
+  llvm::StringMap<std::string> EditedFiles;
+  for (const auto &Case : Cases) {
+    for (const auto &SubCase : expandCases(Case.TestSource)) {
+      ExtraFiles["test.hpp"] = R"cpp(
+namespace one {
+void oo() {}
+namespace two {
+enum ee {ee_one};
+void ff() {}
+class cc {
+public:
+  struct st { struct nested {}; };
+  static void mm() {}
+};
+}
+using uu = two::cc;
+})cpp";
+      EXPECT_EQ(apply(SubCase, &EditedFiles), Case.ExpectedSource);
+    }
+  }
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
new file mode 100644
index 000000000000..4c218f5f7b04
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
@@ -0,0 +1,34 @@
+//===-- AnnotateHighlightingsTests.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 "TweakTesting.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(AnnotateHighlightings);
+
+TEST_F(AnnotateHighlightingsTest, Test) {
+  EXPECT_AVAILABLE("^vo^id^ ^f(^) {^}^"); // available everywhere.
+  EXPECT_AVAILABLE("[[int a; int b;]]");
+  EXPECT_EQ("void /* entity.name.function.cpp */f() {}", apply("void ^f() {}"));
+
+  EXPECT_EQ(apply("[[void f1(); void f2();]]"),
+            "void /* entity.name.function.cpp */f1(); "
+            "void /* entity.name.function.cpp */f2();");
+
+  EXPECT_EQ(apply("void f1(); void f2() {^}"),
+            "void f1(); "
+            "void /* entity.name.function.cpp */f2() {}");
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/DefineInlineTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/DefineInlineTests.cpp
new file mode 100644
index 000000000000..f190a314bc4a
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/DefineInlineTests.cpp
@@ -0,0 +1,1008 @@
+//===-- DefineInlineTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::ElementsAre;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(DefineInline);
+
+TEST_F(DefineInlineTest, TriggersOnFunctionDecl) {
+  // Basic check for function body and signature.
+  EXPECT_AVAILABLE(R"cpp(
+  class Bar {
+    void baz();
+  };
+
+  [[void [[Bar::[[b^a^z]]]]() [[{
+    return;
+  }]]]]
+
+  void foo();
+  [[void [[f^o^o]]() [[{
+    return;
+  }]]]]
+  )cpp");
+
+  EXPECT_UNAVAILABLE(R"cpp(
+  // Not a definition
+  vo^i[[d^ ^f]]^oo();
+
+  [[vo^id ]]foo[[()]] {[[
+    [[(void)(5+3);
+    return;]]
+  }]]
+
+  // Definition with no body.
+  class Bar { Bar() = def^ault; };
+  )cpp");
+}
+
+TEST_F(DefineInlineTest, NoForwardDecl) {
+  Header = "void bar();";
+  EXPECT_UNAVAILABLE(R"cpp(
+  void bar() {
+    return;
+  }
+  // FIXME: Generate a decl in the header.
+  void fo^o() {
+    return;
+  })cpp");
+}
+
+TEST_F(DefineInlineTest, ReferencedDecls) {
+  EXPECT_AVAILABLE(R"cpp(
+    void bar();
+    void foo(int test);
+
+    void fo^o(int baz) {
+      int x = 10;
+      bar();
+    })cpp");
+
+  // Internal symbol usage.
+  Header = "void foo(int test);";
+  EXPECT_UNAVAILABLE(R"cpp(
+    void bar();
+    void fo^o(int baz) {
+      int x = 10;
+      bar();
+    })cpp");
+
+  // Becomes available after making symbol visible.
+  Header = "void bar();" + Header;
+  EXPECT_AVAILABLE(R"cpp(
+    void fo^o(int baz) {
+      int x = 10;
+      bar();
+    })cpp");
+
+  // FIXME: Move declaration below bar to make it visible.
+  Header.clear();
+  EXPECT_UNAVAILABLE(R"cpp(
+    void foo();
+    void bar();
+
+    void fo^o() {
+      bar();
+    })cpp");
+
+  // Order doesn't matter within a class.
+  EXPECT_AVAILABLE(R"cpp(
+    class Bar {
+      void foo();
+      void bar();
+    };
+
+    void Bar::fo^o() {
+      bar();
+    })cpp");
+
+  // FIXME: Perform include insertion to make symbol visible.
+  ExtraFiles["a.h"] = "void bar();";
+  Header = "void foo(int test);";
+  EXPECT_UNAVAILABLE(R"cpp(
+    #include "a.h"
+    void fo^o(int baz) {
+      int x = 10;
+      bar();
+    })cpp");
+}
+
+TEST_F(DefineInlineTest, TemplateSpec) {
+  EXPECT_UNAVAILABLE(R"cpp(
+    template <typename T> void foo();
+    template<> void foo<char>();
+
+    template<> void f^oo<int>() {
+    })cpp");
+  EXPECT_UNAVAILABLE(R"cpp(
+    template <typename T> void foo();
+
+    template<> void f^oo<int>() {
+    })cpp");
+  EXPECT_UNAVAILABLE(R"cpp(
+    template <typename T> struct Foo { void foo(); };
+
+    template <typename T> void Foo<T>::f^oo() {
+    })cpp");
+  EXPECT_AVAILABLE(R"cpp(
+    template <typename T> void foo();
+    void bar();
+    template <> void foo<int>();
+
+    template<> void f^oo<int>() {
+      bar();
+    })cpp");
+  EXPECT_UNAVAILABLE(R"cpp(
+    namespace bar {
+      template <typename T> void f^oo() {}
+      template void foo<int>();
+    })cpp");
+}
+
+TEST_F(DefineInlineTest, CheckForCanonDecl) {
+  EXPECT_UNAVAILABLE(R"cpp(
+    void foo();
+
+    void bar() {}
+    void f^oo() {
+      // This bar normally refers to the definition just above, but it is not
+      // visible from the forward declaration of foo.
+      bar();
+    })cpp");
+  // Make it available with a forward decl.
+  EXPECT_AVAILABLE(R"cpp(
+    void bar();
+    void foo();
+
+    void bar() {}
+    void f^oo() {
+      bar();
+    })cpp");
+}
+
+TEST_F(DefineInlineTest, UsingShadowDecls) {
+  // Template body is not parsed until instantiation time on windows, which
+  // results in arbitrary failures as function body becomes NULL.
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  EXPECT_UNAVAILABLE(R"cpp(
+  namespace ns1 { void foo(int); }
+  namespace ns2 { void foo(int*); }
+  template <typename T>
+  void bar();
+
+  using ns1::foo;
+  using ns2::foo;
+
+  template <typename T>
+  void b^ar() {
+    foo(T());
+  })cpp");
+}
+
+TEST_F(DefineInlineTest, TransformNestedNamespaces) {
+  auto Test = R"cpp(
+    namespace a {
+      void bar();
+      namespace b {
+        void baz();
+        namespace c {
+          void aux();
+        }
+      }
+    }
+
+    void foo();
+    using namespace a;
+    using namespace b;
+    using namespace c;
+    void f^oo() {
+      bar();
+      a::bar();
+
+      baz();
+      b::baz();
+      a::b::baz();
+
+      aux();
+      c::aux();
+      b::c::aux();
+      a::b::c::aux();
+    })cpp";
+  auto Expected = R"cpp(
+    namespace a {
+      void bar();
+      namespace b {
+        void baz();
+        namespace c {
+          void aux();
+        }
+      }
+    }
+
+    void foo(){
+      a::bar();
+      a::bar();
+
+      a::b::baz();
+      a::b::baz();
+      a::b::baz();
+
+      a::b::c::aux();
+      a::b::c::aux();
+      a::b::c::aux();
+      a::b::c::aux();
+    }
+    using namespace a;
+    using namespace b;
+    using namespace c;
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformUsings) {
+  auto Test = R"cpp(
+    namespace a { namespace b { namespace c { void aux(); } } }
+
+    void foo();
+    void f^oo() {
+      using namespace a;
+      using namespace b;
+      using namespace c;
+      using c::aux;
+      namespace d = c;
+    })cpp";
+  auto Expected = R"cpp(
+    namespace a { namespace b { namespace c { void aux(); } } }
+
+    void foo(){
+      using namespace a;
+      using namespace a::b;
+      using namespace a::b::c;
+      using a::b::c::aux;
+      namespace d = a::b::c;
+    }
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformDecls) {
+  auto Test = R"cpp(
+    void foo();
+    void f^oo() {
+      class Foo {
+      public:
+        void foo();
+        int x;
+      };
+
+      enum En { Zero, One };
+      En x = Zero;
+
+      enum class EnClass { Zero, One };
+      EnClass y = EnClass::Zero;
+    })cpp";
+  auto Expected = R"cpp(
+    void foo(){
+      class Foo {
+      public:
+        void foo();
+        int x;
+      };
+
+      enum En { Zero, One };
+      En x = Zero;
+
+      enum class EnClass { Zero, One };
+      EnClass y = EnClass::Zero;
+    }
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformTemplDecls) {
+  auto Test = R"cpp(
+    namespace a {
+      template <typename T> class Bar {
+      public:
+        void bar();
+      };
+      template <typename T> T bar;
+      template <typename T> void aux() {}
+    }
+
+    void foo();
+
+    using namespace a;
+    void f^oo() {
+      bar<Bar<int>>.bar();
+      aux<Bar<int>>();
+    })cpp";
+  auto Expected = R"cpp(
+    namespace a {
+      template <typename T> class Bar {
+      public:
+        void bar();
+      };
+      template <typename T> T bar;
+      template <typename T> void aux() {}
+    }
+
+    void foo(){
+      a::bar<a::Bar<int>>.bar();
+      a::aux<a::Bar<int>>();
+    }
+
+    using namespace a;
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformMembers) {
+  auto Test = R"cpp(
+    class Foo {
+      void foo();
+    };
+
+    void Foo::f^oo() {
+      return;
+    })cpp";
+  auto Expected = R"cpp(
+    class Foo {
+      void foo(){
+      return;
+    }
+    };
+
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+
+  ExtraFiles["a.h"] = R"cpp(
+    class Foo {
+      void foo();
+    };)cpp";
+
+  llvm::StringMap<std::string> EditedFiles;
+  Test = R"cpp(
+    #include "a.h"
+    void Foo::f^oo() {
+      return;
+    })cpp";
+  Expected = R"cpp(
+    #include "a.h"
+    )cpp";
+  EXPECT_EQ(apply(Test, &EditedFiles), Expected);
+
+  Expected = R"cpp(
+    class Foo {
+      void foo(){
+      return;
+    }
+    };)cpp";
+  EXPECT_THAT(EditedFiles,
+              ElementsAre(FileWithContents(testPath("a.h"), Expected)));
+}
+
+TEST_F(DefineInlineTest, TransformDependentTypes) {
+  auto Test = R"cpp(
+    namespace a {
+      template <typename T> class Bar {};
+    }
+
+    template <typename T>
+    void foo();
+
+    using namespace a;
+    template <typename T>
+    void f^oo() {
+      Bar<T> B;
+      Bar<Bar<T>> q;
+    })cpp";
+  auto Expected = R"cpp(
+    namespace a {
+      template <typename T> class Bar {};
+    }
+
+    template <typename T>
+    void foo(){
+      a::Bar<T> B;
+      a::Bar<a::Bar<T>> q;
+    }
+
+    using namespace a;
+    )cpp";
+
+  // Template body is not parsed until instantiation time on windows, which
+  // results in arbitrary failures as function body becomes NULL.
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformFunctionTempls) {
+  // Check we select correct specialization decl.
+  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
+      {R"cpp(
+          template <typename T>
+          void foo(T p);
+
+          template <>
+          void foo<int>(int p);
+
+          template <>
+          void foo<char>(char p);
+
+          template <>
+          void fo^o<int>(int p) {
+            return;
+          })cpp",
+       R"cpp(
+          template <typename T>
+          void foo(T p);
+
+          template <>
+          void foo<int>(int p){
+            return;
+          }
+
+          template <>
+          void foo<char>(char p);
+
+          )cpp"},
+      {// Make sure we are not selecting the first specialization all the time.
+       R"cpp(
+          template <typename T>
+          void foo(T p);
+
+          template <>
+          void foo<int>(int p);
+
+          template <>
+          void foo<char>(char p);
+
+          template <>
+          void fo^o<char>(char p) {
+            return;
+          })cpp",
+       R"cpp(
+          template <typename T>
+          void foo(T p);
+
+          template <>
+          void foo<int>(int p);
+
+          template <>
+          void foo<char>(char p){
+            return;
+          }
+
+          )cpp"},
+      {R"cpp(
+          template <typename T>
+          void foo(T p);
+
+          template <>
+          void foo<int>(int p);
+
+          template <typename T>
+          void fo^o(T p) {
+            return;
+          })cpp",
+       R"cpp(
+          template <typename T>
+          void foo(T p){
+            return;
+          }
+
+          template <>
+          void foo<int>(int p);
+
+          )cpp"},
+  };
+  // Template body is not parsed until instantiation time on windows, which
+  // results in arbitrary failures as function body becomes NULL.
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  for (const auto &Case : Cases)
+    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
+}
+
+TEST_F(DefineInlineTest, TransformTypeLocs) {
+  auto Test = R"cpp(
+    namespace a {
+      template <typename T> class Bar {
+      public:
+        template <typename Q> class Baz {};
+      };
+      class Foo{};
+    }
+
+    void foo();
+
+    using namespace a;
+    void f^oo() {
+      Bar<int> B;
+      Foo foo;
+      a::Bar<Bar<int>>::Baz<Bar<int>> q;
+    })cpp";
+  auto Expected = R"cpp(
+    namespace a {
+      template <typename T> class Bar {
+      public:
+        template <typename Q> class Baz {};
+      };
+      class Foo{};
+    }
+
+    void foo(){
+      a::Bar<int> B;
+      a::Foo foo;
+      a::Bar<a::Bar<int>>::Baz<a::Bar<int>> q;
+    }
+
+    using namespace a;
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformDeclRefs) {
+  auto Test = R"cpp(
+    namespace a {
+      template <typename T> class Bar {
+      public:
+        void foo();
+        static void bar();
+        int x;
+        static int y;
+      };
+      void bar();
+      void test();
+    }
+
+    void foo();
+    using namespace a;
+    void f^oo() {
+      a::Bar<int> B;
+      B.foo();
+      a::bar();
+      Bar<Bar<int>>::bar();
+      a::Bar<int>::bar();
+      B.x = Bar<int>::y;
+      Bar<int>::y = 3;
+      bar();
+      a::test();
+    })cpp";
+  auto Expected = R"cpp(
+    namespace a {
+      template <typename T> class Bar {
+      public:
+        void foo();
+        static void bar();
+        int x;
+        static int y;
+      };
+      void bar();
+      void test();
+    }
+
+    void foo(){
+      a::Bar<int> B;
+      B.foo();
+      a::bar();
+      a::Bar<a::Bar<int>>::bar();
+      a::Bar<int>::bar();
+      B.x = a::Bar<int>::y;
+      a::Bar<int>::y = 3;
+      a::bar();
+      a::test();
+    }
+    using namespace a;
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, StaticMembers) {
+  auto Test = R"cpp(
+    namespace ns { class X { static void foo(); void bar(); }; }
+    void ns::X::b^ar() {
+      foo();
+    })cpp";
+  auto Expected = R"cpp(
+    namespace ns { class X { static void foo(); void bar(){
+      foo();
+    } }; }
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformParamNames) {
+  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
+      {R"cpp(
+        void foo(int, bool b, int T\
+est);
+        void ^foo(int f, bool x, int z) {})cpp",
+       R"cpp(
+        void foo(int f, bool x, int z){}
+        )cpp"},
+      {R"cpp(
+        #define PARAM int Z
+        void foo(PARAM);
+
+        void ^foo(int X) {})cpp",
+       "fail: Cant rename parameter inside macro body."},
+      {R"cpp(
+        #define TYPE int
+        #define PARAM TYPE Z
+        #define BODY(x) 5 * (x) + 2
+        template <int P>
+        void foo(PARAM, TYPE Q, TYPE, TYPE W = BODY(P));
+        template <int x>
+        void ^foo(int Z, int b, int c, int d) {})cpp",
+       R"cpp(
+        #define TYPE int
+        #define PARAM TYPE Z
+        #define BODY(x) 5 * (x) + 2
+        template <int x>
+        void foo(PARAM, TYPE b, TYPE c, TYPE d = BODY(x)){}
+        )cpp"},
+  };
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  for (const auto &Case : Cases)
+    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
+}
+
+TEST_F(DefineInlineTest, TransformTemplParamNames) {
+  auto Test = R"cpp(
+    struct Foo {
+      struct Bar {
+        template <class, class X,
+                  template<typename> class, template<typename> class Y,
+                  int, int Z>
+        void foo(X, Y<X>, int W = 5 * Z + 2);
+      };
+    };
+
+    template <class T, class U,
+              template<typename> class V, template<typename> class W,
+              int X, int Y>
+    void Foo::Bar::f^oo(U, W<U>, int Q) {})cpp";
+  auto Expected = R"cpp(
+    struct Foo {
+      struct Bar {
+        template <class T, class U,
+                  template<typename> class V, template<typename> class W,
+                  int X, int Y>
+        void foo(U, W<U>, int Q = 5 * Y + 2){}
+      };
+    };
+
+    )cpp";
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TransformInlineNamespaces) {
+  auto Test = R"cpp(
+    namespace a { inline namespace b { namespace { struct Foo{}; } } }
+    void foo();
+
+    using namespace a;
+    void ^foo() {Foo foo;})cpp";
+  auto Expected = R"cpp(
+    namespace a { inline namespace b { namespace { struct Foo{}; } } }
+    void foo(){a::Foo foo;}
+
+    using namespace a;
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected);
+}
+
+TEST_F(DefineInlineTest, TokensBeforeSemicolon) {
+  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
+      {R"cpp(
+          void foo()    /*Comment -_-*/ /*Com 2*/ ;
+          void fo^o() { return ; })cpp",
+       R"cpp(
+          void foo()    /*Comment -_-*/ /*Com 2*/ { return ; }
+          )cpp"},
+
+      {R"cpp(
+          void foo();
+          void fo^o() { return ; })cpp",
+       R"cpp(
+          void foo(){ return ; }
+          )cpp"},
+
+      {R"cpp(
+          #define SEMI ;
+          void foo() SEMI
+          void fo^o() { return ; })cpp",
+       "fail: Couldn't find semicolon for target declaration."},
+  };
+  for (const auto &Case : Cases)
+    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
+}
+
+TEST_F(DefineInlineTest, HandleMacros) {
+  EXPECT_UNAVAILABLE(R"cpp(
+    #define BODY { return; }
+    void foo();
+    void f^oo()BODY)cpp");
+
+  EXPECT_UNAVAILABLE(R"cpp(
+    #define BODY void foo(){ return; }
+    void foo();
+    [[BODY]])cpp");
+
+  std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
+      // We don't qualify declarations coming from macros.
+      {R"cpp(
+          #define BODY Foo
+          namespace a { class Foo{}; }
+          void foo();
+          using namespace a;
+          void f^oo(){BODY();})cpp",
+       R"cpp(
+          #define BODY Foo
+          namespace a { class Foo{}; }
+          void foo(){BODY();}
+          using namespace a;
+          )cpp"},
+
+      // Macro is not visible at declaration location, but we proceed.
+      {R"cpp(
+          void foo();
+          #define BODY return;
+          void f^oo(){BODY})cpp",
+       R"cpp(
+          void foo(){BODY}
+          #define BODY return;
+          )cpp"},
+
+      {R"cpp(
+          #define TARGET void foo()
+          TARGET;
+          void f^oo(){ return; })cpp",
+       R"cpp(
+          #define TARGET void foo()
+          TARGET{ return; }
+          )cpp"},
+
+      {R"cpp(
+          #define TARGET foo
+          void TARGET();
+          void f^oo(){ return; })cpp",
+       R"cpp(
+          #define TARGET foo
+          void TARGET(){ return; }
+          )cpp"},
+  };
+  for (const auto &Case : Cases)
+    EXPECT_EQ(apply(Case.first), Case.second) << Case.first;
+}
+
+TEST_F(DefineInlineTest, DropCommonNameSpecifiers) {
+  struct {
+    llvm::StringRef Test;
+    llvm::StringRef Expected;
+  } Cases[] = {
+      {R"cpp(
+        namespace a { namespace b { void aux(); } }
+        namespace ns1 {
+          void foo();
+          namespace qq { void test(); }
+          namespace ns2 {
+            void bar();
+            namespace ns3 { void baz(); }
+          }
+        }
+
+        using namespace a;
+        using namespace a::b;
+        using namespace ns1::qq;
+        void ns1::ns2::ns3::b^az() {
+          foo();
+          bar();
+          baz();
+          ns1::ns2::ns3::baz();
+          aux();
+          test();
+        })cpp",
+       R"cpp(
+        namespace a { namespace b { void aux(); } }
+        namespace ns1 {
+          void foo();
+          namespace qq { void test(); }
+          namespace ns2 {
+            void bar();
+            namespace ns3 { void baz(){
+          foo();
+          bar();
+          baz();
+          ns1::ns2::ns3::baz();
+          a::b::aux();
+          qq::test();
+        } }
+          }
+        }
+
+        using namespace a;
+        using namespace a::b;
+        using namespace ns1::qq;
+        )cpp"},
+      {R"cpp(
+        namespace ns1 {
+          namespace qq { struct Foo { struct Bar {}; }; using B = Foo::Bar; }
+          namespace ns2 { void baz(); }
+        }
+
+        using namespace ns1::qq;
+        void ns1::ns2::b^az() { Foo f; B b; })cpp",
+       R"cpp(
+        namespace ns1 {
+          namespace qq { struct Foo { struct Bar {}; }; using B = Foo::Bar; }
+          namespace ns2 { void baz(){ qq::Foo f; qq::B b; } }
+        }
+
+        using namespace ns1::qq;
+        )cpp"},
+      {R"cpp(
+        namespace ns1 {
+          namespace qq {
+            template<class T> struct Foo { template <class U> struct Bar {}; };
+            template<class T, class U>
+            using B = typename Foo<T>::template Bar<U>;
+          }
+          namespace ns2 { void baz(); }
+        }
+
+        using namespace ns1::qq;
+        void ns1::ns2::b^az() { B<int, bool> b; })cpp",
+       R"cpp(
+        namespace ns1 {
+          namespace qq {
+            template<class T> struct Foo { template <class U> struct Bar {}; };
+            template<class T, class U>
+            using B = typename Foo<T>::template Bar<U>;
+          }
+          namespace ns2 { void baz(){ qq::B<int, bool> b; } }
+        }
+
+        using namespace ns1::qq;
+        )cpp"},
+  };
+  for (const auto &Case : Cases)
+    EXPECT_EQ(apply(Case.Test), Case.Expected) << Case.Test;
+}
+
+TEST_F(DefineInlineTest, QualifyWithUsingDirectives) {
+  llvm::StringRef Test = R"cpp(
+    namespace a {
+      void bar();
+      namespace b { struct Foo{}; void aux(); }
+      namespace c { void cux(); }
+    }
+    using namespace a;
+    using X = b::Foo;
+    void foo();
+
+    using namespace b;
+    using namespace c;
+    void ^foo() {
+      cux();
+      bar();
+      X x;
+      aux();
+      using namespace c;
+      // FIXME: The last reference to cux() in body of foo should not be
+      // qualified, since there is a using directive inside the function body.
+      cux();
+    })cpp";
+  llvm::StringRef Expected = R"cpp(
+    namespace a {
+      void bar();
+      namespace b { struct Foo{}; void aux(); }
+      namespace c { void cux(); }
+    }
+    using namespace a;
+    using X = b::Foo;
+    void foo(){
+      c::cux();
+      bar();
+      X x;
+      b::aux();
+      using namespace c;
+      // FIXME: The last reference to cux() in body of foo should not be
+      // qualified, since there is a using directive inside the function body.
+      c::cux();
+    }
+
+    using namespace b;
+    using namespace c;
+    )cpp";
+  EXPECT_EQ(apply(Test), Expected) << Test;
+}
+
+TEST_F(DefineInlineTest, AddInline) {
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  llvm::StringMap<std::string> EditedFiles;
+  ExtraFiles["a.h"] = "void foo();";
+  apply(R"cpp(#include "a.h"
+              void fo^o() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                               testPath("a.h"), "inline void foo(){}")));
+
+  // Check we put inline before cv-qualifiers.
+  ExtraFiles["a.h"] = "const int foo();";
+  apply(R"cpp(#include "a.h"
+              const int fo^o() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                               testPath("a.h"), "inline const int foo(){}")));
+
+  // No double inline.
+  ExtraFiles["a.h"] = "inline void foo();";
+  apply(R"cpp(#include "a.h"
+              inline void fo^o() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                               testPath("a.h"), "inline void foo(){}")));
+
+  // Constexprs don't need "inline".
+  ExtraFiles["a.h"] = "constexpr void foo();";
+  apply(R"cpp(#include "a.h"
+              constexpr void fo^o() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                               testPath("a.h"), "constexpr void foo(){}")));
+
+  // Class members don't need "inline".
+  ExtraFiles["a.h"] = "struct Foo { void foo(); };";
+  apply(R"cpp(#include "a.h"
+              void Foo::fo^o() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles,
+              testing::ElementsAre(FileWithContents(
+                  testPath("a.h"), "struct Foo { void foo(){} };")));
+
+  // Function template doesn't need to be "inline"d.
+  ExtraFiles["a.h"] = "template <typename T> void foo();";
+  apply(R"cpp(#include "a.h"
+              template <typename T>
+              void fo^o() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles,
+              testing::ElementsAre(FileWithContents(
+                  testPath("a.h"), "template <typename T> void foo(){}")));
+
+  // Specializations needs to be marked "inline".
+  ExtraFiles["a.h"] = R"cpp(
+                            template <typename T> void foo();
+                            template <> void foo<int>();)cpp";
+  apply(R"cpp(#include "a.h"
+              template <>
+              void fo^o<int>() {})cpp",
+        &EditedFiles);
+  EXPECT_THAT(EditedFiles,
+              testing::ElementsAre(FileWithContents(testPath("a.h"),
+                                                    R"cpp(
+                            template <typename T> void foo();
+                            template <> inline void foo<int>(){})cpp")));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/DefineOutlineTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/DefineOutlineTests.cpp
new file mode 100644
index 000000000000..1a49a3750335
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/DefineOutlineTests.cpp
@@ -0,0 +1,541 @@
+//===-- 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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::ElementsAre;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(DefineOutline);
+
+TEST_F(DefineOutlineTest, TriggersOnFunctionDecl) {
+  FileName = "Test.cpp";
+  // Not available unless in a header file.
+  EXPECT_UNAVAILABLE(R"cpp(
+    [[void [[f^o^o]]() [[{
+      return;
+    }]]]])cpp");
+
+  FileName = "Test.hpp";
+  // Not available unless function name or fully body is selected.
+  EXPECT_UNAVAILABLE(R"cpp(
+    // Not a definition
+    vo^i[[d^ ^f]]^oo();
+
+    [[vo^id ]]foo[[()]] {[[
+      [[(void)(5+3);
+      return;]]
+    }]])cpp");
+
+  // Available even if there are no implementation files.
+  EXPECT_AVAILABLE(R"cpp(
+    [[void [[f^o^o]]() [[{
+      return;
+    }]]]])cpp");
+
+  // Not available for out-of-line methods.
+  EXPECT_UNAVAILABLE(R"cpp(
+    class Bar {
+      void baz();
+    };
+
+    [[void [[Bar::[[b^a^z]]]]() [[{
+      return;
+    }]]]])cpp");
+
+  // Basic check for function body and signature.
+  EXPECT_AVAILABLE(R"cpp(
+    class Bar {
+      [[void [[f^o^o^]]() [[{ return; }]]]]
+    };
+
+    void foo();
+    [[void [[f^o^o]]() [[{
+      return;
+    }]]]])cpp");
+
+  // Not available on defaulted/deleted members.
+  EXPECT_UNAVAILABLE(R"cpp(
+    class Foo {
+      Fo^o() = default;
+      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);
+}
+
+TEST_F(DefineOutlineTest, ApplyTest) {
+  llvm::StringMap<std::string> EditedFiles;
+  ExtraFiles["Test.cpp"] = "";
+  FileName = "Test.hpp";
+  // Template body is not parsed until instantiation time on windows, which
+  // results in arbitrary failures as function body becomes NULL.
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+
+  struct {
+    llvm::StringRef Test;
+    llvm::StringRef ExpectedHeader;
+    llvm::StringRef ExpectedSource;
+  } Cases[] = {
+      // Simple check
+      {
+          "void fo^o() { return; }",
+          "void foo() ;",
+          "void foo() { 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
+      {
+          R"cpp(
+            class Foo {public: Foo(); Foo(int);};
+            class Bar {
+              Ba^r() {}
+              Bar(int x) : f1(x) {}
+              Foo f1;
+              Foo f2 = 2;
+            };)cpp",
+          R"cpp(
+            class Foo {public: Foo(); Foo(int);};
+            class Bar {
+              Bar() ;
+              Bar(int x) : f1(x) {}
+              Foo f1;
+              Foo f2 = 2;
+            };)cpp",
+          "Bar::Bar() {}\n",
+      },
+      // Ctor with initializer.
+      {
+          R"cpp(
+            class Foo {public: Foo(); Foo(int);};
+            class Bar {
+              Bar() {}
+              B^ar(int x) : f1(x), f2(3) {}
+              Foo f1;
+              Foo f2 = 2;
+            };)cpp",
+          R"cpp(
+            class Foo {public: Foo(); Foo(int);};
+            class Bar {
+              Bar() {}
+              Bar(int x) ;
+              Foo f1;
+              Foo f2 = 2;
+            };)cpp",
+          "Bar::Bar(int x) : f1(x), f2(3) {}\n",
+      },
+      // Ctor initializer with attribute.
+      {
+          R"cpp(
+              class Foo {
+                F^oo(int z) __attribute__((weak)) : bar(2){}
+                int bar;
+              };)cpp",
+          R"cpp(
+              class Foo {
+                Foo(int z) __attribute__((weak)) ;
+                int bar;
+              };)cpp",
+          "Foo::Foo(int z) __attribute__((weak)) : bar(2){}\n",
+      },
+      // Virt specifiers.
+      {
+          R"cpp(
+            struct A {
+              virtual void f^oo() {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              virtual void foo() ;
+            };)cpp",
+          " void A::foo() {}\n",
+      },
+      {
+          R"cpp(
+            struct A {
+              virtual virtual void virtual f^oo() {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              virtual virtual void virtual foo() ;
+            };)cpp",
+          "  void  A::foo() {}\n",
+      },
+      {
+          R"cpp(
+            struct A {
+              virtual void foo() = 0;
+            };
+            struct B : A {
+              void fo^o() override {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              virtual void foo() = 0;
+            };
+            struct B : A {
+              void foo() override ;
+            };)cpp",
+          "void B::foo()  {}\n",
+      },
+      {
+          R"cpp(
+            struct A {
+              virtual void foo() = 0;
+            };
+            struct B : A {
+              void fo^o() final {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              virtual void foo() = 0;
+            };
+            struct B : A {
+              void foo() final ;
+            };)cpp",
+          "void B::foo()  {}\n",
+      },
+      {
+          R"cpp(
+            struct A {
+              virtual void foo() = 0;
+            };
+            struct B : A {
+              void fo^o() final override {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              virtual void foo() = 0;
+            };
+            struct B : A {
+              void foo() final override ;
+            };)cpp",
+          "void B::foo()   {}\n",
+      },
+      {
+          R"cpp(
+            struct A {
+              static void fo^o() {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              static void foo() ;
+            };)cpp",
+          " void A::foo() {}\n",
+      },
+      {
+          R"cpp(
+            struct A {
+              static static void fo^o() {}
+            };)cpp",
+          R"cpp(
+            struct A {
+              static static void foo() ;
+            };)cpp",
+          "  void A::foo() {}\n",
+      },
+  };
+  for (const auto &Case : Cases) {
+    SCOPED_TRACE(Case.Test);
+    EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
+    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                                 testPath("Test.cpp"), Case.ExpectedSource)));
+  }
+}
+
+TEST_F(DefineOutlineTest, HandleMacros) {
+  llvm::StringMap<std::string> EditedFiles;
+  ExtraFiles["Test.cpp"] = "";
+  FileName = "Test.hpp";
+  ExtraArgs.push_back("-DVIRTUAL=virtual");
+  ExtraArgs.push_back("-DOVER=override");
+
+  struct {
+    llvm::StringRef Test;
+    llvm::StringRef ExpectedHeader;
+    llvm::StringRef ExpectedSource;
+  } Cases[] = {
+      {R"cpp(
+          #define BODY { return; }
+          void f^oo()BODY)cpp",
+       R"cpp(
+          #define BODY { return; }
+          void foo();)cpp",
+       "void foo()BODY"},
+
+      {R"cpp(
+          #define BODY return;
+          void f^oo(){BODY})cpp",
+       R"cpp(
+          #define BODY return;
+          void foo();)cpp",
+       "void foo(){BODY}"},
+
+      {R"cpp(
+          #define TARGET void foo()
+          [[TARGET]]{ return; })cpp",
+       R"cpp(
+          #define TARGET void foo()
+          TARGET;)cpp",
+       "TARGET{ return; }"},
+
+      {R"cpp(
+          #define TARGET foo
+          void [[TARGET]](){ return; })cpp",
+       R"cpp(
+          #define TARGET foo
+          void TARGET();)cpp",
+       "void TARGET(){ return; }"},
+      {R"cpp(#define VIRT virtual
+          struct A {
+            VIRT void f^oo() {}
+          };)cpp",
+       R"cpp(#define VIRT virtual
+          struct A {
+            VIRT void foo() ;
+          };)cpp",
+       " void A::foo() {}\n"},
+      {R"cpp(
+          struct A {
+            VIRTUAL void f^oo() {}
+          };)cpp",
+       R"cpp(
+          struct A {
+            VIRTUAL void foo() ;
+          };)cpp",
+       " void A::foo() {}\n"},
+      {R"cpp(
+          struct A {
+            virtual void foo() = 0;
+          };
+          struct B : A {
+            void fo^o() OVER {}
+          };)cpp",
+       R"cpp(
+          struct A {
+            virtual void foo() = 0;
+          };
+          struct B : A {
+            void foo() OVER ;
+          };)cpp",
+       "void B::foo()  {}\n"},
+      {R"cpp(#define STUPID_MACRO(X) virtual
+          struct A {
+            STUPID_MACRO(sizeof sizeof int) void f^oo() {}
+          };)cpp",
+       R"cpp(#define STUPID_MACRO(X) virtual
+          struct A {
+            STUPID_MACRO(sizeof sizeof int) void foo() ;
+          };)cpp",
+       " void A::foo() {}\n"},
+      {R"cpp(#define STAT static
+          struct A {
+            STAT void f^oo() {}
+          };)cpp",
+       R"cpp(#define STAT static
+          struct A {
+            STAT void foo() ;
+          };)cpp",
+       " void A::foo() {}\n"},
+      {R"cpp(#define STUPID_MACRO(X) static
+          struct A {
+            STUPID_MACRO(sizeof sizeof int) void f^oo() {}
+          };)cpp",
+       R"cpp(#define STUPID_MACRO(X) static
+          struct A {
+            STUPID_MACRO(sizeof sizeof int) void foo() ;
+          };)cpp",
+       " void A::foo() {}\n"},
+  };
+  for (const auto &Case : Cases) {
+    SCOPED_TRACE(Case.Test);
+    EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
+    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                                 testPath("Test.cpp"), Case.ExpectedSource)));
+  }
+}
+
+TEST_F(DefineOutlineTest, QualifyReturnValue) {
+  FileName = "Test.hpp";
+  ExtraFiles["Test.cpp"] = "";
+
+  struct {
+    llvm::StringRef Test;
+    llvm::StringRef ExpectedHeader;
+    llvm::StringRef ExpectedSource;
+  } Cases[] = {
+      {R"cpp(
+        namespace a { class Foo{}; }
+        using namespace a;
+        Foo fo^o() { return {}; })cpp",
+       R"cpp(
+        namespace a { class Foo{}; }
+        using namespace a;
+        Foo foo() ;)cpp",
+       "a::Foo foo() { return {}; }"},
+      {R"cpp(
+        namespace a {
+          class Foo {
+            class Bar {};
+            Bar fo^o() { return {}; }
+          };
+        })cpp",
+       R"cpp(
+        namespace a {
+          class Foo {
+            class Bar {};
+            Bar foo() ;
+          };
+        })cpp",
+       "a::Foo::Bar a::Foo::foo() { return {}; }\n"},
+      {R"cpp(
+        class Foo {};
+        Foo fo^o() { return {}; })cpp",
+       R"cpp(
+        class Foo {};
+        Foo foo() ;)cpp",
+       "Foo foo() { return {}; }"},
+  };
+  llvm::StringMap<std::string> EditedFiles;
+  for (auto &Case : Cases) {
+    apply(Case.Test, &EditedFiles);
+    EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
+    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                                 testPath("Test.cpp"), Case.ExpectedSource)));
+  }
+}
+
+TEST_F(DefineOutlineTest, QualifyFunctionName) {
+  FileName = "Test.hpp";
+  struct {
+    llvm::StringRef TestHeader;
+    llvm::StringRef TestSource;
+    llvm::StringRef ExpectedHeader;
+    llvm::StringRef ExpectedSource;
+  } Cases[] = {
+      {
+          R"cpp(
+            namespace a {
+              namespace b {
+                class Foo {
+                  void fo^o() {}
+                };
+              }
+            })cpp",
+          "",
+          R"cpp(
+            namespace a {
+              namespace b {
+                class Foo {
+                  void foo() ;
+                };
+              }
+            })cpp",
+          "void a::b::Foo::foo() {}\n",
+      },
+      {
+          "namespace a { namespace b { void f^oo() {} } }",
+          "namespace a{}",
+          "namespace a { namespace b { void foo() ; } }",
+          "namespace a{void b::foo() {} }",
+      },
+      {
+          "namespace a { namespace b { void f^oo() {} } }",
+          "using namespace a;",
+          "namespace a { namespace b { void foo() ; } }",
+          // FIXME: Take using namespace directives in the source file into
+          // account. This can be spelled as b::foo instead.
+          "using namespace a;void a::b::foo() {} ",
+      },
+  };
+  llvm::StringMap<std::string> EditedFiles;
+  for (auto &Case : Cases) {
+    ExtraFiles["Test.cpp"] = std::string(Case.TestSource);
+    EXPECT_EQ(apply(Case.TestHeader, &EditedFiles), Case.ExpectedHeader);
+    EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
+                                 testPath("Test.cpp"), Case.ExpectedSource)))
+        << Case.TestHeader;
+  }
+}
+
+TEST_F(DefineOutlineTest, FailsMacroSpecifier) {
+  FileName = "Test.hpp";
+  ExtraFiles["Test.cpp"] = "";
+  ExtraArgs.push_back("-DFINALOVER=final override");
+
+  std::pair<StringRef, StringRef> Cases[] = {
+      {
+          R"cpp(
+          #define VIRT virtual void
+          struct A {
+            VIRT fo^o() {}
+          };)cpp",
+          "fail: define outline: couldn't remove `virtual` keyword."},
+      {
+          R"cpp(
+          #define OVERFINAL final override
+          struct A {
+            virtual void foo() {}
+          };
+          struct B : A {
+            void fo^o() OVERFINAL {}
+          };)cpp",
+          "fail: define outline: Can't move out of line as function has a "
+          "macro `override` specifier.\ndefine outline: Can't move out of line "
+          "as function has a macro `final` specifier."},
+      {
+          R"cpp(
+          struct A {
+            virtual void foo() {}
+          };
+          struct B : A {
+            void fo^o() FINALOVER {}
+          };)cpp",
+          "fail: define outline: Can't move out of line as function has a "
+          "macro `override` specifier.\ndefine outline: Can't move out of line "
+          "as function has a macro `final` specifier."},
+  };
+  for (const auto &Case : Cases) {
+    EXPECT_EQ(apply(Case.first), Case.second);
+  }
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/DumpASTTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/DumpASTTests.cpp
new file mode 100644
index 000000000000..fe9ab9a70999
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/DumpASTTests.cpp
@@ -0,0 +1,36 @@
+//===-- DumpASTTests.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 "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::AllOf;
+using ::testing::HasSubstr;
+using ::testing::StartsWith;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(DumpAST);
+
+TEST_F(DumpASTTest, Test) {
+  EXPECT_AVAILABLE("^int f^oo() { re^turn 2 ^+ 2; }");
+  EXPECT_UNAVAILABLE("/*c^omment*/ int foo() { return 2 ^ + 2; }");
+  EXPECT_THAT(apply("int x = 2 ^+ 2;"),
+              AllOf(StartsWith("message:"), HasSubstr("BinaryOperator"),
+                    HasSubstr("'+'"), HasSubstr("|-IntegerLiteral"),
+                    HasSubstr("<col:9> 'int' 2\n`-IntegerLiteral"),
+                    HasSubstr("<col:13> 'int' 2")));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/DumpRecordLayoutTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/DumpRecordLayoutTests.cpp
new file mode 100644
index 000000000000..75478dbb3b94
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/DumpRecordLayoutTests.cpp
@@ -0,0 +1,37 @@
+//===-- DumpRecordLayoutTests.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 "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::AllOf;
+using ::testing::HasSubstr;
+using ::testing::StartsWith;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(DumpRecordLayout);
+
+TEST_F(DumpRecordLayoutTest, Test) {
+  EXPECT_AVAILABLE("^s^truct ^X ^{ int x; ^};");
+  EXPECT_THAT("struct X { int ^a; };", Not(isAvailable()));
+  EXPECT_THAT("struct ^X;", Not(isAvailable()));
+  EXPECT_THAT("template <typename T> struct ^X { T t; };", Not(isAvailable()));
+  EXPECT_THAT("enum ^X {};", Not(isAvailable()));
+
+  EXPECT_THAT(apply("struct ^X { int x; int y; };"),
+              AllOf(StartsWith("message:"), HasSubstr("0 |   int x")));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/DumpSymbolTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/DumpSymbolTests.cpp
new file mode 100644
index 000000000000..2a239275d4b1
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/DumpSymbolTests.cpp
@@ -0,0 +1,35 @@
+//===-- DumpSymbolTests.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 "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <string>
+
+using ::testing::AllOf;
+using ::testing::HasSubstr;
+using ::testing::StartsWith;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(DumpSymbol);
+
+TEST_F(DumpSymbolTest, Test) {
+  std::string ID = R"("id":"CA2EBE44A1D76D2A")";
+  std::string USR = R"("usr":"c:@F at foo#")";
+  EXPECT_THAT(apply("void f^oo();"),
+              AllOf(StartsWith("message:"), testing::HasSubstr(ID),
+                    testing::HasSubstr(USR)));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/ExpandAutoTypeTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/ExpandAutoTypeTests.cpp
new file mode 100644
index 000000000000..ba783e551e84
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/ExpandAutoTypeTests.cpp
@@ -0,0 +1,82 @@
+//===-- ExpandAutoTypeTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::StartsWith;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(ExpandAutoType);
+
+TEST_F(ExpandAutoTypeTest, Test) {
+  Header = R"cpp(
+    namespace ns {
+      struct Class {
+        struct Nested {};
+      };
+      void Func();
+    }
+    inline namespace inl_ns {
+      namespace {
+        struct Visible {};
+      }
+    }
+  )cpp";
+
+  EXPECT_AVAILABLE("^a^u^t^o^ i = 0;");
+  EXPECT_UNAVAILABLE("auto ^i^ ^=^ ^0^;^");
+
+  // check primitive type
+  EXPECT_EQ(apply("[[auto]] i = 0;"), "int i = 0;");
+  EXPECT_EQ(apply("au^to i = 0;"), "int i = 0;");
+  // check classes and namespaces
+  EXPECT_EQ(apply("^auto C = ns::Class::Nested();"),
+            "ns::Class::Nested C = ns::Class::Nested();");
+  // check that namespaces are shortened
+  EXPECT_EQ(apply("namespace ns { void f() { ^auto C = Class(); } }"),
+            "namespace ns { void f() { Class C = Class(); } }");
+  // undefined functions should not be replaced
+  EXPECT_THAT(apply("au^to x = doesnt_exist(); // error-ok"),
+              StartsWith("fail: Could not deduce type for 'auto' type"));
+  // function pointers should not be replaced
+  EXPECT_THAT(apply("au^to x = &ns::Func;"),
+              StartsWith("fail: Could not expand type of function pointer"));
+  // lambda types are not replaced
+  EXPECT_UNAVAILABLE("au^to x = []{};");
+  // inline namespaces
+  EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
+            "Visible x = inl_ns::Visible();");
+  // local class
+  EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
+            "namespace x { void y() { struct S{}; S z = S(); } }");
+  // replace array types
+  EXPECT_EQ(apply(R"cpp(au^to x = "test";)cpp"),
+            R"cpp(const char * x = "test";)cpp");
+
+  EXPECT_UNAVAILABLE("dec^ltype(au^to) x = 10;");
+  // expanding types in structured bindings is syntactically invalid.
+  EXPECT_UNAVAILABLE("const ^auto &[x,y] = (int[]){1,2};");
+
+  // FIXME: Auto-completion in a template requires disabling delayed template
+  // parsing.
+  ExtraArgs.push_back("-fno-delayed-template-parsing");
+  // unknown types in a template should not be replaced
+  EXPECT_THAT(apply("template <typename T> void x() { ^auto y = T::z(); }"),
+              StartsWith("fail: Could not deduce type for 'auto' type"));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/ExpandMacroTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/ExpandMacroTests.cpp
new file mode 100644
index 000000000000..6602fc7e6e6e
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/ExpandMacroTests.cpp
@@ -0,0 +1,55 @@
+//===-- ExpandMacroTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(ExpandMacro);
+
+TEST_F(ExpandMacroTest, Test) {
+  Header = R"cpp(
+    // error-ok: not real c++, just token manipulation
+    #define FOO 1 2 3
+    #define FUNC(X) X+X+X
+    #define EMPTY
+    #define EMPTY_FN(X)
+  )cpp";
+
+  // Available on macro names, not available anywhere else.
+  EXPECT_AVAILABLE("^F^O^O^ BAR ^F^O^O^");
+  EXPECT_AVAILABLE("^F^U^N^C^(1)");
+  EXPECT_UNAVAILABLE("^#^d^efine^ ^XY^Z 1 ^2 ^3^");
+  EXPECT_UNAVAILABLE("FOO ^B^A^R^ FOO ^");
+  EXPECT_UNAVAILABLE("FUNC(^1^)^");
+
+  // Works as expected on object-like macros.
+  EXPECT_EQ(apply("^FOO BAR FOO"), "1 2 3 BAR FOO");
+  EXPECT_EQ(apply("FOO BAR ^FOO"), "FOO BAR 1 2 3");
+  // And function-like macros.
+  EXPECT_EQ(apply("F^UNC(2)"), "2 + 2 + 2");
+
+  // Works on empty macros.
+  EXPECT_EQ(apply("int a ^EMPTY;"), "int a ;");
+  EXPECT_EQ(apply("int a ^EMPTY_FN(1 2 3);"), "int a ;");
+  EXPECT_EQ(apply("int a = 123 ^EMPTY EMPTY_FN(1);"),
+            "int a = 123  EMPTY_FN(1);");
+  EXPECT_EQ(apply("int a = 123 ^EMPTY_FN(1) EMPTY;"), "int a = 123  EMPTY;");
+  EXPECT_EQ(apply("int a = 123 EMPTY_FN(1) ^EMPTY;"),
+            "int a = 123 EMPTY_FN(1) ;");
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/ExtractFunctionTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/ExtractFunctionTests.cpp
new file mode 100644
index 000000000000..2033b479896b
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/ExtractFunctionTests.cpp
@@ -0,0 +1,202 @@
+//===-- ExtractFunctionTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::HasSubstr;
+using ::testing::StartsWith;
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(ExtractFunction);
+
+TEST_F(ExtractFunctionTest, FunctionTest) {
+  Context = Function;
+
+  // Root statements should have common parent.
+  EXPECT_EQ(apply("for(;;) [[1+2; 1+2;]]"), "unavailable");
+  // Expressions aren't extracted.
+  EXPECT_EQ(apply("int x = 0; [[x++;]]"), "unavailable");
+  // We don't support extraction from lambdas.
+  EXPECT_EQ(apply("auto lam = [](){ [[int x;]] }; "), "unavailable");
+  // Partial statements aren't extracted.
+  EXPECT_THAT(apply("int [[x = 0]];"), "unavailable");
+  // FIXME: Support hoisting.
+  EXPECT_THAT(apply(" [[int a = 5;]] a++; "), "unavailable");
+
+  // Ensure that end of Zone and Beginning of PostZone being adjacent doesn't
+  // lead to break being included in the extraction zone.
+  EXPECT_THAT(apply("for(;;) { [[int x;]]break; }"), HasSubstr("extracted"));
+  // FIXME: ExtractFunction should be unavailable inside loop construct
+  // initializer/condition.
+  EXPECT_THAT(apply(" for([[int i = 0;]];);"), HasSubstr("extracted"));
+  // Extract certain return
+  EXPECT_THAT(apply(" if(true) [[{ return; }]] "), HasSubstr("extracted"));
+  // Don't extract uncertain return
+  EXPECT_THAT(apply(" if(true) [[if (false) return;]] "),
+              StartsWith("unavailable"));
+  EXPECT_THAT(
+      apply("#define RETURN_IF_ERROR(x) if (x) return\nRETU^RN_IF_ERROR(4);"),
+      StartsWith("unavailable"));
+
+  FileName = "a.c";
+  EXPECT_THAT(apply(" for([[int i = 0;]];);"), HasSubstr("unavailable"));
+}
+
+TEST_F(ExtractFunctionTest, FileTest) {
+  // Check all parameters are in order
+  std::string ParameterCheckInput = R"cpp(
+struct Foo {
+  int x;
+};
+void f(int a) {
+  int b;
+  int *ptr = &a;
+  Foo foo;
+  [[a += foo.x + b;
+  *ptr++;]]
+})cpp";
+  std::string ParameterCheckOutput = R"cpp(
+struct Foo {
+  int x;
+};
+void extracted(int &a, int &b, int * &ptr, Foo &foo) {
+a += foo.x + b;
+  *ptr++;
+}
+void f(int a) {
+  int b;
+  int *ptr = &a;
+  Foo foo;
+  extracted(a, b, ptr, foo);
+})cpp";
+  EXPECT_EQ(apply(ParameterCheckInput), ParameterCheckOutput);
+
+  // Check const qualifier
+  std::string ConstCheckInput = R"cpp(
+void f(const int c) {
+  [[while(c) {}]]
+})cpp";
+  std::string ConstCheckOutput = R"cpp(
+void extracted(const int &c) {
+while(c) {}
+}
+void f(const int c) {
+  extracted(c);
+})cpp";
+  EXPECT_EQ(apply(ConstCheckInput), ConstCheckOutput);
+
+  // Don't extract when we need to make a function as a parameter.
+  EXPECT_THAT(apply("void f() { [[int a; f();]] }"), StartsWith("fail"));
+
+  // We don't extract from methods for now since they may involve multi-file
+  // edits
+  std::string MethodFailInput = R"cpp(
+    class T {
+      void f() {
+        [[int x;]]
+      }
+    };
+  )cpp";
+  EXPECT_EQ(apply(MethodFailInput), "unavailable");
+
+  // We don't extract from templated functions for now as templates are hard
+  // to deal with.
+  std::string TemplateFailInput = R"cpp(
+    template<typename T>
+    void f() {
+      [[int x;]]
+    }
+  )cpp";
+  EXPECT_EQ(apply(TemplateFailInput), "unavailable");
+
+  std::string MacroInput = R"cpp(
+    #define F(BODY) void f() { BODY }
+    F ([[int x = 0;]])
+  )cpp";
+  std::string MacroOutput = R"cpp(
+    #define F(BODY) void f() { BODY }
+    void extracted() {
+int x = 0;
+}
+F (extracted();)
+  )cpp";
+  EXPECT_EQ(apply(MacroInput), MacroOutput);
+
+  // Shouldn't crash.
+  EXPECT_EQ(apply("void f([[int a]]);"), "unavailable");
+  // Don't extract if we select the entire function body (CompoundStmt).
+  std::string CompoundFailInput = R"cpp(
+    void f() [[{
+      int a;
+    }]]
+  )cpp";
+  EXPECT_EQ(apply(CompoundFailInput), "unavailable");
+}
+
+TEST_F(ExtractFunctionTest, ControlFlow) {
+  Context = Function;
+  // We should be able to extract break/continue with a parent loop/switch.
+  EXPECT_THAT(apply(" [[for(;;) if(1) break;]] "), HasSubstr("extracted"));
+  EXPECT_THAT(apply(" for(;;) [[while(1) break;]] "), HasSubstr("extracted"));
+  EXPECT_THAT(apply(" [[switch(1) { break; }]]"), HasSubstr("extracted"));
+  EXPECT_THAT(apply(" [[while(1) switch(1) { continue; }]]"),
+              HasSubstr("extracted"));
+  // Don't extract break and continue without a loop/switch parent.
+  EXPECT_THAT(apply(" for(;;) [[if(1) continue;]] "), StartsWith("fail"));
+  EXPECT_THAT(apply(" while(1) [[if(1) break;]] "), StartsWith("fail"));
+  EXPECT_THAT(apply(" switch(1) { [[break;]] }"), StartsWith("fail"));
+  EXPECT_THAT(apply(" for(;;) { [[while(1) break; break;]] }"),
+              StartsWith("fail"));
+}
+
+TEST_F(ExtractFunctionTest, ExistingReturnStatement) {
+  Context = File;
+  const char *Before = R"cpp(
+    bool lucky(int N);
+    int getNum(bool Superstitious, int Min, int Max) {
+      if (Superstitious) [[{
+        for (int I = Min; I <= Max; ++I)
+          if (lucky(I))
+            return I;
+        return -1;
+      }]] else {
+        return (Min + Max) / 2;
+      }
+    }
+  )cpp";
+  // FIXME: min/max should be by value.
+  // FIXME: avoid emitting redundant braces
+  const char *After = R"cpp(
+    bool lucky(int N);
+    int extracted(int &Min, int &Max) {
+{
+        for (int I = Min; I <= Max; ++I)
+          if (lucky(I))
+            return I;
+        return -1;
+      }
+}
+int getNum(bool Superstitious, int Min, int Max) {
+      if (Superstitious) return extracted(Min, Max); else {
+        return (Min + Max) / 2;
+      }
+    }
+  )cpp";
+  EXPECT_EQ(apply(Before), After);
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp
new file mode 100644
index 000000000000..4e9223cfe553
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp
@@ -0,0 +1,300 @@
+//===-- ExtractVariableTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(ExtractVariable);
+
+TEST_F(ExtractVariableTest, Test) {
+  const char *AvailableCases = R"cpp(
+    int xyz(int a = 1) {
+      struct T {
+        int bar(int a = 1);
+        int z;
+      } t;
+      // return statement
+      return [[[[t.b[[a]]r]](t.z)]];
+    }
+    void f() {
+      int a = [[5 +]] [[4 * [[[[xyz]]()]]]];
+      // multivariable initialization
+      if(1)
+        int x = [[1]], y = [[a + 1]], a = [[1]], z = a + 1;
+      // if without else
+      if([[1]])
+        a = [[1]] + 1;
+      // if with else
+      if(a < [[3]])
+        if(a == [[4]])
+          a = [[5]] + 1;
+        else
+          a = [[5]] + 1;
+      else if (a < [[4]])
+        a = [[4]] + 1;
+      else
+        a = [[5]] + 1;
+      // for loop
+      for(a = [[1]] + 1; a > [[[[3]] + [[4]]]]; a++)
+        a = [[2]] + 1;
+      // while
+      while(a < [[1]])
+        a = [[1]] + 1;
+      // do while
+      do
+        a = [[1]] + 1;
+      while(a < [[3]]);
+    }
+  )cpp";
+  EXPECT_AVAILABLE(AvailableCases);
+
+  ExtraArgs = {"-xc"};
+  const char *AvailableButC = R"cpp(
+    void foo() {
+      int x = [[1]];
+    })cpp";
+  EXPECT_UNAVAILABLE(AvailableButC);
+  ExtraArgs = {};
+
+  const char *NoCrashCases = R"cpp(
+    // error-ok: broken code, but shouldn't crash
+    template<typename T, typename ...Args>
+    struct Test<T, Args...> {
+    Test(const T &v) :val[[(^]]) {}
+      T val;
+    };
+  )cpp";
+  EXPECT_UNAVAILABLE(NoCrashCases);
+
+  const char *UnavailableCases = R"cpp(
+    int xyz(int a = [[1]]) {
+      struct T {
+        int bar(int a = [[1]]);
+        int z = [[1]];
+      } t;
+      return [[t]].bar([[[[t]].z]]);
+    }
+    void v() { return; }
+    // function default argument
+    void f(int b = [[1]]) {
+      // empty selection
+      int a = ^1 ^+ ^2;
+      // void expressions
+      auto i = new int, j = new int;
+      [[[[delete i]], delete j]];
+      [[v]]();
+      // if
+      if(1)
+        int x = 1, y = a + 1, a = 1, z = [[a + 1]];
+      if(int a = 1)
+        if([[a + 1]] == 4)
+          a = [[[[a]] +]] 1;
+      // for loop
+      for(int a = 1, b = 2, c = 3; a > [[b + c]]; [[a++]])
+        a = [[a + 1]];
+      // lambda
+      auto lamb = [&[[a]], &[[b]]](int r = [[1]]) {return 1;};
+      // assignment
+      xyz([[a = 5]]);
+      xyz([[a *= 5]]);
+      // Variable DeclRefExpr
+      a = [[b]];
+      a = [[xyz()]];
+      // statement expression
+      [[xyz()]];
+      while (a)
+        [[++a]];
+      // label statement
+      goto label;
+      label:
+        a = [[1]];
+    }
+  )cpp";
+  EXPECT_UNAVAILABLE(UnavailableCases);
+
+  // vector of pairs of input and output strings
+  const std::vector<std::pair<std::string, std::string>> InputOutputs = {
+      // extraction from variable declaration/assignment
+      {R"cpp(void varDecl() {
+                   int a = 5 * (4 + (3 [[- 1)]]);
+                 })cpp",
+       R"cpp(void varDecl() {
+                   auto dummy = (3 - 1); int a = 5 * (4 + dummy);
+                 })cpp"},
+      // FIXME: extraction from switch case
+      /*{R"cpp(void f(int a) {
+               if(1)
+                 while(a < 1)
+                   switch (1) {
+                       case 1:
+                         a = [[1 + 2]];
+                         break;
+                       default:
+                         break;
+                   }
+             })cpp",
+       R"cpp(void f(int a) {
+               auto dummy = 1 + 2; if(1)
+                 while(a < 1)
+                   switch (1) {
+                       case 1:
+                         a = dummy;
+                         break;
+                       default:
+                         break;
+                   }
+             })cpp"},*/
+      // Macros
+      {R"cpp(#define PLUS(x) x++
+                 void f(int a) {
+                   int y = PLUS([[1+a]]);
+                 })cpp",
+       /*FIXME: It should be extracted like this.
+        R"cpp(#define PLUS(x) x++
+              void f(int a) {
+                auto dummy = 1+a; int y = PLUS(dummy);
+              })cpp"},*/
+       R"cpp(#define PLUS(x) x++
+                 void f(int a) {
+                   auto dummy = PLUS(1+a); int y = dummy;
+                 })cpp"},
+      // ensure InsertionPoint isn't inside a macro
+      {R"cpp(#define LOOP(x) while (1) {a = x;}
+                 void f(int a) {
+                   if(1)
+                    LOOP(5 + [[3]])
+                 })cpp",
+       R"cpp(#define LOOP(x) while (1) {a = x;}
+                 void f(int a) {
+                   auto dummy = 3; if(1)
+                    LOOP(5 + dummy)
+                 })cpp"},
+      {R"cpp(#define LOOP(x) do {x;} while(1);
+                 void f(int a) {
+                   if(1)
+                    LOOP(5 + [[3]])
+                 })cpp",
+       R"cpp(#define LOOP(x) do {x;} while(1);
+                 void f(int a) {
+                   auto dummy = 3; if(1)
+                    LOOP(5 + dummy)
+                 })cpp"},
+      // attribute testing
+      {R"cpp(void f(int a) {
+                    [ [gsl::suppress("type")] ] for (;;) a = [[1]] + 1;
+                 })cpp",
+       R"cpp(void f(int a) {
+                    auto dummy = 1; [ [gsl::suppress("type")] ] for (;;) a = dummy + 1;
+                 })cpp"},
+      // MemberExpr
+      {R"cpp(class T {
+                   T f() {
+                     return [[T().f()]].f();
+                   }
+                 };)cpp",
+       R"cpp(class T {
+                   T f() {
+                     auto dummy = T().f(); return dummy.f();
+                   }
+                 };)cpp"},
+      // Function DeclRefExpr
+      {R"cpp(int f() {
+                   return [[f]]();
+                 })cpp",
+       R"cpp(int f() {
+                   auto dummy = f(); return dummy;
+                 })cpp"},
+      // FIXME: Wrong result for \[\[clang::uninitialized\]\] int b = [[1]];
+      // since the attr is inside the DeclStmt and the bounds of
+      // DeclStmt don't cover the attribute.
+
+      // Binary subexpressions
+      {R"cpp(void f() {
+                   int x = 1 + [[2 + 3 + 4]] + 5;
+                 })cpp",
+       R"cpp(void f() {
+                   auto dummy = 2 + 3 + 4; int x = 1 + dummy + 5;
+                 })cpp"},
+      {R"cpp(void f() {
+                   int x = [[1 + 2 + 3]] + 4 + 5;
+                 })cpp",
+       R"cpp(void f() {
+                   auto dummy = 1 + 2 + 3; int x = dummy + 4 + 5;
+                 })cpp"},
+      {R"cpp(void f() {
+                   int x = 1 + 2 + [[3 + 4 + 5]];
+                 })cpp",
+       R"cpp(void f() {
+                   auto dummy = 3 + 4 + 5; int x = 1 + 2 + dummy;
+                 })cpp"},
+      // Non-associative operations have no special support
+      {R"cpp(void f() {
+                   int x = 1 - [[2 - 3 - 4]] - 5;
+                 })cpp",
+       R"cpp(void f() {
+                   auto dummy = 1 - 2 - 3 - 4; int x = dummy - 5;
+                 })cpp"},
+      // A mix of associative operators isn't associative.
+      {R"cpp(void f() {
+                   int x = 0 + 1 * [[2 + 3]] * 4 + 5;
+                 })cpp",
+       R"cpp(void f() {
+                   auto dummy = 1 * 2 + 3 * 4; int x = 0 + dummy + 5;
+                 })cpp"},
+      // Overloaded operators are supported, we assume associativity
+      // as if they were built-in.
+      {R"cpp(struct S {
+                   S(int);
+                 };
+                 S operator+(S, S);
+
+                 void f() {
+                   S x = S(1) + [[S(2) + S(3) + S(4)]] + S(5);
+                 })cpp",
+       R"cpp(struct S {
+                   S(int);
+                 };
+                 S operator+(S, S);
+
+                 void f() {
+                   auto dummy = S(2) + S(3) + S(4); S x = S(1) + dummy + S(5);
+                 })cpp"},
+      // Don't try to analyze across macro boundaries
+      // FIXME: it'd be nice to do this someday (in a safe way)
+      {R"cpp(#define ECHO(X) X
+                 void f() {
+                   int x = 1 + [[ECHO(2 + 3) + 4]] + 5;
+                 })cpp",
+       R"cpp(#define ECHO(X) X
+                 void f() {
+                   auto dummy = 1 + ECHO(2 + 3) + 4; int x = dummy + 5;
+                 })cpp"},
+      {R"cpp(#define ECHO(X) X
+                 void f() {
+                   int x = 1 + [[ECHO(2) + ECHO(3) + 4]] + 5;
+                 })cpp",
+       R"cpp(#define ECHO(X) X
+                 void f() {
+                   auto dummy = 1 + ECHO(2) + ECHO(3) + 4; int x = dummy + 5;
+                 })cpp"},
+  };
+  for (const auto &IO : InputOutputs) {
+    EXPECT_EQ(IO.second, apply(IO.first)) << IO.first;
+  }
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/ObjCLocalizeStringLiteralTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/ObjCLocalizeStringLiteralTests.cpp
new file mode 100644
index 000000000000..d52a1b3a78c1
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/ObjCLocalizeStringLiteralTests.cpp
@@ -0,0 +1,41 @@
+//===-- ObjCLocalizeStringLiteralTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(ObjCLocalizeStringLiteral);
+
+TEST_F(ObjCLocalizeStringLiteralTest, Test) {
+  ExtraArgs.push_back("-x");
+  ExtraArgs.push_back("objective-c");
+
+  // Ensure the action can be initiated in the string literal.
+  EXPECT_AVAILABLE(R"(id x = ^[[@[[^"^t^est^"]]]];)");
+
+  // Ensure that the action can't be initiated in other places.
+  EXPECT_UNAVAILABLE(R"([[i^d ^[[x]] ^= @"test";^]])");
+
+  // Ensure that the action is not available for regular C strings.
+  EXPECT_UNAVAILABLE(R"(const char * x= "^test";)");
+
+  const char *Input = R"(id x = [[@"test"]];)";
+  const char *Output = R"(id x = NSLocalizedString(@"test", @"");)";
+  EXPECT_EQ(apply(Input), Output);
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/PopulateSwitchTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/PopulateSwitchTests.cpp
new file mode 100644
index 000000000000..41518108a4f8
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/PopulateSwitchTests.cpp
@@ -0,0 +1,213 @@
+//===-- PopulateSwitchTest.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(PopulateSwitch);
+
+TEST_F(PopulateSwitchTest, Test) {
+  struct Case {
+    CodeContext Context;
+    llvm::StringRef TestSource;
+    llvm::StringRef ExpectedSource;
+  };
+
+  Case Cases[]{
+      {
+          // No enumerators
+          Function,
+          R""(enum Enum {}; ^switch ((Enum)0) {})"",
+          "unavailable",
+      },
+      {
+          // All enumerators already in switch (unscoped)
+          Function,
+          R""(enum Enum {A,B}; ^switch (A) {case A:break;case B:break;})"",
+          "unavailable",
+      },
+      {
+          // All enumerators already in switch (scoped)
+          Function,
+          R""(
+            enum class Enum {A,B};
+            ^switch (Enum::A) {case Enum::A:break;case Enum::B:break;}
+          )"",
+          "unavailable",
+      },
+      {
+          // Default case in switch
+          Function,
+          R""(
+            enum class Enum {A,B};
+            ^switch (Enum::A) {default:break;}
+          )"",
+          "unavailable",
+      },
+      {
+          // GNU range in switch
+          Function,
+          R""(
+            enum class Enum {A,B};
+            ^switch (Enum::A) {case Enum::A ... Enum::B:break;}
+          )"",
+          "unavailable",
+      },
+      {
+          // Value dependent case expression
+          File,
+          R""(
+            enum class Enum {A,B};
+            template<Enum Value>
+            void function() {
+                ^switch (Enum::A) {case Value:break;}
+            }
+          )"",
+          "unavailable",
+      },
+      {
+          // Body not CompoundStmt
+          Function,
+          R""(enum Enum {A}; ^switch (A);)"",
+          "unavailable",
+      },
+      {
+          // Selection on switch token
+          Function,
+          R""(enum Enum {A}; ^switch (A) {})"",
+          R""(enum Enum {A}; switch (A) {case A:break;})"",
+      },
+      {
+          // Selection on switch condition
+          Function,
+          R""(enum Enum {A}; switch (^A) {})"",
+          R""(enum Enum {A}; switch (A) {case A:break;})"",
+      },
+      {
+          // Selection in switch body
+          Function,
+          R""(enum Enum {A}; switch (A) {^})"",
+          R""(enum Enum {A}; switch (A) {case A:break;})"",
+      },
+      {
+          // Scoped enumeration
+          Function,
+          R""(enum class Enum {A}; ^switch (Enum::A) {})"",
+          R""(enum class Enum {A}; switch (Enum::A) {case Enum::A:break;})"",
+      },
+      {
+          // Scoped enumeration with multiple enumerators
+          Function,
+          R""(
+            enum class Enum {A,B};
+            ^switch (Enum::A) {}
+          )"",
+          R""(
+            enum class Enum {A,B};
+            switch (Enum::A) {case Enum::A:case Enum::B:break;}
+          )"",
+      },
+      {
+          // Only filling in missing enumerators (unscoped)
+          Function,
+          R""(
+            enum Enum {A,B,C};
+            ^switch (A) {case B:break;}
+          )"",
+          R""(
+            enum Enum {A,B,C};
+            switch (A) {case B:break;case A:case C:break;}
+          )"",
+      },
+      {
+          // Only filling in missing enumerators,
+          // even when using integer literals
+          Function,
+          R""(
+            enum Enum {A,B=1,C};
+            ^switch (A) {case 1:break;}
+          )"",
+          R""(
+            enum Enum {A,B=1,C};
+            switch (A) {case 1:break;case A:case C:break;}
+          )"",
+      },
+      {
+          // Only filling in missing enumerators (scoped)
+          Function,
+          R""(
+            enum class Enum {A,B,C};
+            ^switch (Enum::A)
+            {case Enum::B:break;}
+          )"",
+          R""(
+            enum class Enum {A,B,C};
+            switch (Enum::A)
+            {case Enum::B:break;case Enum::A:case Enum::C:break;}
+          )"",
+      },
+      {
+          // Scoped enumerations in namespace
+          File,
+          R""(
+            namespace ns { enum class Enum {A}; }
+            void function() { ^switch (ns::Enum::A) {} }
+          )"",
+          R""(
+            namespace ns { enum class Enum {A}; }
+            void function() { switch (ns::Enum::A) {case ns::Enum::A:break;} }
+          )"",
+      },
+      {
+          // Unscoped enumerations in namespace
+          File,
+          R""(
+            namespace ns { enum Enum {A}; }
+            void function() { ^switch (ns::A) {} }
+          )"",
+          R""(
+            namespace ns { enum Enum {A}; }
+            void function() { switch (ns::A) {case ns::A:break;} }
+          )"",
+      },
+      {
+          // Duplicated constant names
+          Function,
+          R""(enum Enum {A,B,b=B}; ^switch (A) {})"",
+          R""(enum Enum {A,B,b=B}; switch (A) {case A:case B:break;})"",
+      },
+      {
+          // Duplicated constant names all in switch
+          Function,
+          R""(enum Enum {A,B,b=B}; ^switch (A) {case A:case B:break;})"",
+          "unavailable",
+      },
+      {
+          // Enum is dependent type
+          File,
+          R""(template<typename T> void f() {enum Enum {A}; ^switch (A) {}})"",
+          "unavailable",
+      },
+  };
+
+  for (const auto &Case : Cases) {
+    Context = Case.Context;
+    EXPECT_EQ(apply(Case.TestSource), Case.ExpectedSource);
+  }
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/RawStringLiteralTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/RawStringLiteralTests.cpp
new file mode 100644
index 000000000000..db92928ba3d0
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/RawStringLiteralTests.cpp
@@ -0,0 +1,42 @@
+//===-- RawStringLiteralTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(RawStringLiteral);
+
+TEST_F(RawStringLiteralTest, Test) {
+  Context = Expression;
+  EXPECT_AVAILABLE(R"cpp(^"^f^o^o^\^n^")cpp");
+  EXPECT_AVAILABLE(R"cpp(R"(multi )" ^"token " "str\ning")cpp");
+  EXPECT_UNAVAILABLE(R"cpp(^"f^o^o^o")cpp"); // no chars need escaping
+  EXPECT_UNAVAILABLE(R"cpp(R"(multi )" ^"token " u8"str\ning")cpp"); // nonascii
+  EXPECT_UNAVAILABLE(R"cpp(^R^"^(^multi )" "token " "str\ning")cpp"); // raw
+  EXPECT_UNAVAILABLE(R"cpp(^"token\n" __FILE__)cpp"); // chunk is macro
+  EXPECT_UNAVAILABLE(R"cpp(^"a\r\n";)cpp");           // forbidden escape char
+
+  const char *Input = R"cpp(R"(multi
+token)" "\nst^ring\n" "literal")cpp";
+  const char *Output = R"cpp(R"(multi
+token
+string
+literal)")cpp";
+  EXPECT_EQ(apply(Input), Output);
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp
new file mode 100644
index 000000000000..3a15f05041ad
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp
@@ -0,0 +1,237 @@
+//===-- RemoveUsingNamespaceTest.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(RemoveUsingNamespace);
+
+TEST_F(RemoveUsingNamespaceTest, All) {
+  std::pair<llvm::StringRef /*Input*/, llvm::StringRef /*Expected*/> Cases[] = {
+      {// Remove all occurrences of ns. Qualify only unqualified.
+       R"cpp(
+      namespace ns1 { struct vector {}; }
+      namespace ns2 { struct map {}; }
+      using namespace n^s1;
+      using namespace ns2;
+      using namespace ns1;
+      int main() {
+        ns1::vector v1;
+        vector v2;
+        map m1;
+      }
+    )cpp",
+       R"cpp(
+      namespace ns1 { struct vector {}; }
+      namespace ns2 { struct map {}; }
+      
+      using namespace ns2;
+      
+      int main() {
+        ns1::vector v1;
+        ns1::vector v2;
+        map m1;
+      }
+    )cpp"},
+      {// Ident to be qualified is a macro arg.
+       R"cpp(
+      #define DECLARE(x, y) x y
+      namespace ns { struct vector {}; }
+      using namespace n^s;
+      int main() {
+        DECLARE(ns::vector, v1);
+        DECLARE(vector, v2);
+      }
+    )cpp",
+       R"cpp(
+      #define DECLARE(x, y) x y
+      namespace ns { struct vector {}; }
+      
+      int main() {
+        DECLARE(ns::vector, v1);
+        DECLARE(ns::vector, v2);
+      }
+    )cpp"},
+      {// Nested namespace: Fully qualify ident from inner ns.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace aa::b^b;
+      int main() {
+        map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      int main() {
+        aa::bb::map m;
+      }
+    )cpp"},
+      {// Nested namespace: Fully qualify ident from inner ns.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace a^a;
+      int main() {
+        bb::map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      int main() {
+        aa::bb::map m;
+      }
+    )cpp"},
+      {// Typedef.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace a^a;
+      typedef bb::map map;
+      int main() { map M; }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      typedef aa::bb::map map;
+      int main() { map M; }
+    )cpp"},
+      {// FIXME: Nested namespaces: Not aware of using ns decl of outer ns.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using name[[space aa::b]]b;
+      using namespace aa;
+      int main() {
+        map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      
+      using namespace aa;
+      int main() {
+        aa::bb::map m;
+      }
+    )cpp"},
+      {// Does not qualify ident from inner namespace.
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace aa::bb;
+      using namespace a^a;
+      int main() {
+        map m;
+      }
+    )cpp",
+       R"cpp(
+      namespace aa { namespace bb { struct map {}; }}
+      using namespace aa::bb;
+      
+      int main() {
+        map m;
+      }
+    )cpp"},
+      {// Available only for top level namespace decl.
+       R"cpp(
+        namespace aa {
+          namespace bb { struct map {}; }
+          using namespace b^b;
+        }
+        int main() { aa::map m; }
+    )cpp",
+       "unavailable"},
+      {// FIXME: Unavailable for namespaces containing using-namespace decl.
+       R"cpp(
+      namespace aa {
+        namespace bb { struct map {}; }
+        using namespace bb;
+      }
+      using namespace a^a;
+      int main() {
+        map m;
+      }
+    )cpp",
+       "unavailable"},
+      {R"cpp(
+      namespace a::b { struct Foo {}; }
+      using namespace a;
+      using namespace a::[[b]];
+      using namespace b;
+      int main() { Foo F;}
+    )cpp",
+       R"cpp(
+      namespace a::b { struct Foo {}; }
+      using namespace a;
+      
+      
+      int main() { a::b::Foo F;}
+    )cpp"},
+      {R"cpp(
+      namespace a::b { struct Foo {}; }
+      using namespace a;
+      using namespace a::b;
+      using namespace [[b]];
+      int main() { Foo F;}
+    )cpp",
+       R"cpp(
+      namespace a::b { struct Foo {}; }
+      using namespace a;
+      
+      
+      int main() { b::Foo F;}
+    )cpp"},
+      {// Enumerators.
+       R"cpp(
+      namespace tokens {
+      enum Token {
+        comma, identifier, numeric
+      };
+      }
+      using namespace tok^ens;
+      int main() {
+        auto x = comma;
+      }
+    )cpp",
+       R"cpp(
+      namespace tokens {
+      enum Token {
+        comma, identifier, numeric
+      };
+      }
+      
+      int main() {
+        auto x = tokens::comma;
+      }
+    )cpp"},
+      {// inline namespaces.
+       R"cpp(
+      namespace std { inline namespace ns1 { inline namespace ns2 { struct vector {}; }}}
+      using namespace st^d;
+      int main() {
+        vector V;
+      }
+    )cpp",
+       R"cpp(
+      namespace std { inline namespace ns1 { inline namespace ns2 { struct vector {}; }}}
+      
+      int main() {
+        std::vector V;
+      }
+    )cpp"}};
+  for (auto C : Cases)
+    EXPECT_EQ(C.second, apply(C.first)) << C.first;
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/ShowSelectionTreeTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/ShowSelectionTreeTests.cpp
new file mode 100644
index 000000000000..8ec3d3801c42
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/ShowSelectionTreeTests.cpp
@@ -0,0 +1,48 @@
+//===-- ShowSelectionTreeTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(ShowSelectionTree);
+
+TEST_F(ShowSelectionTreeTest, Test) {
+  EXPECT_AVAILABLE("^int f^oo() { re^turn 2 ^+ 2; }");
+  EXPECT_AVAILABLE("/*c^omment*/ int foo() { return 2 ^ + 2; }");
+
+  const char *Output = R"(message:
+ TranslationUnitDecl 
+   VarDecl int x = fcall(2 + 2)
+    .CallExpr fcall(2 + 2)
+       ImplicitCastExpr fcall
+        .DeclRefExpr fcall
+      .BinaryOperator 2 + 2
+        *IntegerLiteral 2
+)";
+  EXPECT_EQ(apply("int fcall(int); int x = fca[[ll(2 +]]2);"), Output);
+
+  Output = R"(message:
+ TranslationUnitDecl 
+   FunctionDecl void x()
+     CompoundStmt { …
+       ForStmt for (;;) …
+        *BreakStmt break;
+)";
+  EXPECT_EQ(apply("void x() { for (;;) br^eak; }"), Output);
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/SwapIfBranchesTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/SwapIfBranchesTests.cpp
new file mode 100644
index 000000000000..989cfbfcc237
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/SwapIfBranchesTests.cpp
@@ -0,0 +1,48 @@
+//===-- SwapIfBranchesTests.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 "TestTU.h"
+#include "TweakTesting.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TWEAK_TEST(SwapIfBranches);
+
+TEST_F(SwapIfBranchesTest, Test) {
+  Context = Function;
+  EXPECT_EQ(apply("^if (true) {return;} else {(void)0;}"),
+            "if (true) {(void)0;} else {return;}");
+  EXPECT_EQ(apply("^if (/*error-ok*/) {return;} else {(void)0;}"),
+            "if (/*error-ok*/) {(void)0;} else {return;}")
+      << "broken condition";
+  EXPECT_AVAILABLE("^i^f^^(^t^r^u^e^) { return; } ^e^l^s^e^ { return; }");
+  EXPECT_UNAVAILABLE("if (true) {^return ^;^ } else { ^return^;^ }");
+  // Available in subexpressions of the condition;
+  EXPECT_THAT("if(2 + [[2]] + 2) { return; } else {return;}", isAvailable());
+  // But not as part of the branches.
+  EXPECT_THAT("if(2 + 2 + 2) { [[return]]; } else { return; }",
+              Not(isAvailable()));
+  // Range covers the "else" token, so available.
+  EXPECT_THAT("if(2 + 2 + 2) { return[[; } else {return;]]}", isAvailable());
+  // Not available in compound statements in condition.
+  EXPECT_THAT("if([]{return [[true]];}()) { return; } else { return; }",
+              Not(isAvailable()));
+  // Not available if both sides aren't braced.
+  EXPECT_THAT("^if (1) return; else { return; }", Not(isAvailable()));
+  // Only one if statement is supported!
+  EXPECT_THAT("[[if(1){}else{}if(2){}else{}]]", Not(isAvailable()));
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

diff  --git a/clang-tools-extra/clangd/unittests/TweakTesting.cpp b/clang-tools-extra/clangd/unittests/tweaks/TweakTesting.cpp
similarity index 93%
rename from clang-tools-extra/clangd/unittests/TweakTesting.cpp
rename to clang-tools-extra/clangd/unittests/tweaks/TweakTesting.cpp
index bbb1af46f93c..680280f83149 100644
--- a/clang-tools-extra/clangd/unittests/TweakTesting.cpp
+++ b/clang-tools-extra/clangd/unittests/tweaks/TweakTesting.cpp
@@ -25,12 +25,12 @@ using Context = TweakTest::CodeContext;
 
 std::pair<llvm::StringRef, llvm::StringRef> wrapping(Context Ctx) {
   switch (Ctx) {
-    case TweakTest::File:
-      return {"",""};
-    case TweakTest::Function:
-      return {"void wrapperFunction(){\n", "\n}"};
-    case TweakTest::Expression:
-      return {"auto expressionWrapper(){return\n", "\n;}"};
+  case TweakTest::File:
+    return {"", ""};
+  case TweakTest::Function:
+    return {"void wrapperFunction(){\n", "\n}"};
+  case TweakTest::Expression:
+    return {"auto expressionWrapper(){return\n", "\n;}"};
   }
   llvm_unreachable("Unknown TweakTest::CodeContext enum");
 }
@@ -46,7 +46,8 @@ llvm::StringRef unwrap(Context Ctx, llvm::StringRef Outer) {
   // Don't allow the begin/end wrapping to overlap!
   if (Outer.startswith(Wrapping.first) && Outer.endswith(Wrapping.second) &&
       Outer.size() >= Wrapping.first.size() + Wrapping.second.size())
-    return Outer.drop_front(Wrapping.first.size()).drop_back(Wrapping.second.size());
+    return Outer.drop_front(Wrapping.first.size())
+        .drop_back(Wrapping.second.size());
   return Outer;
 }
 
@@ -157,11 +158,11 @@ std::vector<std::string> TweakTest::expandCases(llvm::StringRef MarkedCode) {
   Annotations Test(MarkedCode);
   llvm::StringRef Code = Test.code();
   std::vector<std::string> Cases;
-  for (const auto& Point : Test.points()) {
+  for (const auto &Point : Test.points()) {
     size_t Offset = llvm::cantFail(positionToOffset(Code, Point));
     Cases.push_back((Code.substr(0, Offset) + "^" + Code.substr(Offset)).str());
   }
-  for (const auto& Range : Test.ranges()) {
+  for (const auto &Range : Test.ranges()) {
     size_t Begin = llvm::cantFail(positionToOffset(Code, Range.start));
     size_t End = llvm::cantFail(positionToOffset(Code, Range.end));
     Cases.push_back((Code.substr(0, Begin) + "[[" +

diff  --git a/clang-tools-extra/clangd/unittests/TweakTesting.h b/clang-tools-extra/clangd/unittests/tweaks/TweakTesting.h
similarity index 97%
rename from clang-tools-extra/clangd/unittests/TweakTesting.h
rename to clang-tools-extra/clangd/unittests/tweaks/TweakTesting.h
index c771149a72fc..7b1a117130ba 100644
--- a/clang-tools-extra/clangd/unittests/TweakTesting.h
+++ b/clang-tools-extra/clangd/unittests/tweaks/TweakTesting.h
@@ -100,6 +100,10 @@ class TweakTest : public ::testing::Test {
   ::testing::Matcher<llvm::StringRef> isAvailable() const;
 };
 
+MATCHER_P2(FileWithContents, FileName, Contents, "") {
+  return arg.first() == FileName && arg.second == Contents;
+}
+
 #define TWEAK_TEST(TweakID)                                                    \
   class TweakID##Test : public ::clang::clangd::TweakTest {                    \
   protected:                                                                   \

diff  --git a/clang-tools-extra/clangd/unittests/tweaks/TweakTests.cpp b/clang-tools-extra/clangd/unittests/tweaks/TweakTests.cpp
new file mode 100644
index 000000000000..cb0b38dc99ec
--- /dev/null
+++ b/clang-tools-extra/clangd/unittests/tweaks/TweakTests.cpp
@@ -0,0 +1,66 @@
+//===-- TweakTests.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 "TestFS.h"
+#include "TestTU.h"
+#include "TweakTesting.h"
+#include "refactor/Tweak.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticIDs.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Rewrite/Core/Rewriter.h"
+#include "clang/Tooling/Core/Replacement.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/VirtualFileSystem.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <cassert>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TEST(FileEdits, AbsolutePath) {
+  auto RelPaths = {"a.h", "foo.cpp", "test/test.cpp"};
+
+  llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> MemFS(
+      new llvm::vfs::InMemoryFileSystem);
+  MemFS->setCurrentWorkingDirectory(testRoot());
+  for (const auto *Path : RelPaths)
+    MemFS->addFile(Path, 0, llvm::MemoryBuffer::getMemBuffer("", Path));
+  FileManager FM(FileSystemOptions(), MemFS);
+  DiagnosticsEngine DE(new DiagnosticIDs, new DiagnosticOptions);
+  SourceManager SM(DE, FM);
+
+  for (const auto *Path : RelPaths) {
+    auto FID = SM.createFileID(*FM.getFile(Path), SourceLocation(),
+                               clang::SrcMgr::C_User);
+    auto Res = Tweak::Effect::fileEdit(SM, FID, tooling::Replacements());
+    ASSERT_THAT_EXPECTED(Res, llvm::Succeeded());
+    EXPECT_EQ(Res->first, testPath(Path));
+  }
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang


        


More information about the llvm-branch-commits mailing list