| #include "clang/Interpreter/CodeCompletion.h" |
| #include "clang/Frontend/CompilerInstance.h" |
| #include "clang/Interpreter/Interpreter.h" |
| #include "clang/Lex/Preprocessor.h" |
| #include "clang/Sema/CodeCompleteConsumer.h" |
| #include "clang/Sema/Sema.h" |
| #include "llvm/LineEditor/LineEditor.h" |
| #include "llvm/Support/Error.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| |
| using namespace clang; |
| namespace { |
| auto CB = clang::IncrementalCompilerBuilder(); |
| |
| static std::unique_ptr<Interpreter> createInterpreter() { |
| auto CI = cantFail(CB.CreateCpp()); |
| return cantFail(clang::Interpreter::create(std::move(CI))); |
| } |
| |
| static std::vector<std::string> runComp(clang::Interpreter &MainInterp, |
| llvm::StringRef Input, |
| llvm::Error &ErrR) { |
| auto CI = CB.CreateCpp(); |
| if (auto Err = CI.takeError()) { |
| ErrR = std::move(Err); |
| return {}; |
| } |
| |
| auto Interp = clang::Interpreter::create(std::move(*CI)); |
| if (auto Err = Interp.takeError()) { |
| // log the error and returns an empty vector; |
| ErrR = std::move(Err); |
| |
| return {}; |
| } |
| |
| std::vector<std::string> Results; |
| std::vector<std::string> Comps; |
| auto *MainCI = (*Interp)->getCompilerInstance(); |
| auto CC = ReplCodeCompleter(); |
| CC.codeComplete(MainCI, Input, /* Lines */ 1, Input.size() + 1, |
| MainInterp.getCompilerInstance(), Results); |
| |
| for (auto Res : Results) |
| if (Res.find(CC.Prefix) == 0) |
| Comps.push_back(Res); |
| return Comps; |
| } |
| |
| TEST(CodeCompletionTest, Sanity) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("int foo = 12;")); |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, "f", Err); |
| EXPECT_EQ((size_t)2, comps.size()); // float and foo |
| EXPECT_EQ(comps[0], std::string("float")); |
| EXPECT_EQ(comps[1], std::string("foo")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, SanityNoneValid) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("int foo = 12;")); |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, "babanana", Err); |
| EXPECT_EQ((size_t)0, comps.size()); // foo and float |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, TwoDecls) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("int application = 12;")); |
| cantFail(Interp->Parse("int apple = 12;")); |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, "app", Err); |
| EXPECT_EQ((size_t)2, comps.size()); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, CompFunDeclsNoError) { |
| auto Interp = createInterpreter(); |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, "void app(", Err); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, TypedDirected) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("int application = 12;")); |
| cantFail(Interp->Parse("char apple = '2';")); |
| cantFail(Interp->Parse("void add(int &SomeInt){}")); |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("add("), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| cantFail(Interp->Parse("int banana = 42;")); |
| |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("add("), Err); |
| EXPECT_EQ((size_t)2, comps.size()); |
| EXPECT_EQ(comps[0], "application"); |
| EXPECT_EQ(comps[1], "banana"); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("add(b"), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], "banana"); |
| EXPECT_EQ((bool)Err, false); |
| } |
| } |
| |
| TEST(CodeCompletionTest, SanityClasses) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("struct Apple{};")); |
| cantFail(Interp->Parse("void takeApple(Apple &a1){}")); |
| cantFail(Interp->Parse("Apple a1;")); |
| cantFail(Interp->Parse("void takeAppleCopy(Apple a1){}")); |
| |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, "takeApple(", Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("a1")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("takeAppleCopy("), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("a1")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| } |
| |
| TEST(CodeCompletionTest, SubClassing) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("struct Fruit {};")); |
| cantFail(Interp->Parse("struct Apple : Fruit{};")); |
| cantFail(Interp->Parse("void takeFruit(Fruit &f){}")); |
| cantFail(Interp->Parse("Apple a1;")); |
| cantFail(Interp->Parse("Fruit f1;")); |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("takeFruit("), Err); |
| EXPECT_EQ((size_t)2, comps.size()); |
| EXPECT_EQ(comps[0], std::string("a1")); |
| EXPECT_EQ(comps[1], std::string("f1")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, MultipleArguments) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse("int foo = 42;")); |
| cantFail(Interp->Parse("char fowl = 'A';")); |
| cantFail(Interp->Parse("void takeTwo(int &a, char b){}")); |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("takeTwo(foo, "), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("fowl")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, Methods) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse( |
| "struct Foo{int add(int a){return 42;} int par(int b){return 42;}};")); |
| cantFail(Interp->Parse("Foo f1;")); |
| |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("f1."), Err); |
| EXPECT_EQ((size_t)2, comps.size()); |
| EXPECT_EQ(comps[0], std::string("add")); |
| EXPECT_EQ(comps[1], std::string("par")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, MethodsInvocations) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse( |
| "struct Foo{int add(int a){return 42;} int par(int b){return 42;}};")); |
| cantFail(Interp->Parse("Foo f1;")); |
| cantFail(Interp->Parse("int a = 84;")); |
| |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("f1.add("), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("a")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, NestedInvocations) { |
| auto Interp = createInterpreter(); |
| cantFail(Interp->Parse( |
| "struct Foo{int add(int a){return 42;} int par(int b){return 42;}};")); |
| cantFail(Interp->Parse("Foo f1;")); |
| cantFail(Interp->Parse("int a = 84;")); |
| cantFail(Interp->Parse("int plus(int a, int b) { return a + b; }")); |
| |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("plus(42, f1.add("), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("a")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| TEST(CodeCompletionTest, TemplateFunctions) { |
| auto Interp = createInterpreter(); |
| cantFail( |
| Interp->Parse("template <typename T> T id(T a) { return a;} ")); |
| cantFail(Interp->Parse("int apple = 84;")); |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("id<int>("), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("apple")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| |
| cantFail(Interp->Parse( |
| "template <typename T> T pickFirst(T a, T b) { return a;} ")); |
| cantFail(Interp->Parse("char pear = '4';")); |
| { |
| auto Err = llvm::Error::success(); |
| auto comps = runComp(*Interp, std::string("pickFirst(apple, "), Err); |
| EXPECT_EQ((size_t)1, comps.size()); |
| EXPECT_EQ(comps[0], std::string("apple")); |
| EXPECT_EQ((bool)Err, false); |
| } |
| } |
| |
| } // anonymous namespace |