| //=== unittests/Sema/CodeCompleteTest.cpp - Code Complete tests ==============// |
| // |
| // 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 "clang/Frontend/CompilerInstance.h" |
| #include "clang/Frontend/FrontendActions.h" |
| #include "clang/Lex/Preprocessor.h" |
| #include "clang/Parse/ParseAST.h" |
| #include "clang/Sema/Sema.h" |
| #include "clang/Sema/SemaDiagnostic.h" |
| #include "clang/Tooling/Tooling.h" |
| #include "llvm/Testing/Support/Annotations.h" |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| #include <cstddef> |
| #include <string> |
| |
| namespace { |
| |
| using namespace clang; |
| using namespace clang::tooling; |
| using ::testing::Each; |
| using ::testing::UnorderedElementsAre; |
| |
| const char TestCCName[] = "test.cc"; |
| |
| struct CompletionContext { |
| std::vector<std::string> VisitedNamespaces; |
| std::string PreferredType; |
| // String representation of std::ptrdiff_t on a given platform. This is a hack |
| // to properly account for different configurations of clang. |
| std::string PtrDiffType; |
| }; |
| |
| class VisitedContextFinder : public CodeCompleteConsumer { |
| public: |
| VisitedContextFinder(CompletionContext &ResultCtx) |
| : CodeCompleteConsumer(/*CodeCompleteOpts=*/{}), ResultCtx(ResultCtx), |
| CCTUInfo(std::make_shared<GlobalCodeCompletionAllocator>()) {} |
| |
| void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, |
| CodeCompletionResult *Results, |
| unsigned NumResults) override { |
| ResultCtx.VisitedNamespaces = |
| getVisitedNamespace(Context.getVisitedContexts()); |
| ResultCtx.PreferredType = Context.getPreferredType().getAsString(); |
| ResultCtx.PtrDiffType = |
| S.getASTContext().getPointerDiffType().getAsString(); |
| } |
| |
| CodeCompletionAllocator &getAllocator() override { |
| return CCTUInfo.getAllocator(); |
| } |
| |
| CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; } |
| |
| private: |
| std::vector<std::string> getVisitedNamespace( |
| CodeCompletionContext::VisitedContextSet VisitedContexts) const { |
| std::vector<std::string> NSNames; |
| for (const auto *Context : VisitedContexts) |
| if (const auto *NS = llvm::dyn_cast<NamespaceDecl>(Context)) |
| NSNames.push_back(NS->getQualifiedNameAsString()); |
| return NSNames; |
| } |
| |
| CompletionContext &ResultCtx; |
| CodeCompletionTUInfo CCTUInfo; |
| }; |
| |
| class CodeCompleteAction : public SyntaxOnlyAction { |
| public: |
| CodeCompleteAction(ParsedSourceLocation P, CompletionContext &ResultCtx) |
| : CompletePosition(std::move(P)), ResultCtx(ResultCtx) {} |
| |
| bool BeginInvocation(CompilerInstance &CI) override { |
| CI.getFrontendOpts().CodeCompletionAt = CompletePosition; |
| CI.setCodeCompletionConsumer(new VisitedContextFinder(ResultCtx)); |
| return true; |
| } |
| |
| private: |
| // 1-based code complete position <Line, Col>; |
| ParsedSourceLocation CompletePosition; |
| CompletionContext &ResultCtx; |
| }; |
| |
| ParsedSourceLocation offsetToPosition(llvm::StringRef Code, size_t Offset) { |
| Offset = std::min(Code.size(), Offset); |
| StringRef Before = Code.substr(0, Offset); |
| int Lines = Before.count('\n'); |
| size_t PrevNL = Before.rfind('\n'); |
| size_t StartOfLine = (PrevNL == StringRef::npos) ? 0 : (PrevNL + 1); |
| return {TestCCName, static_cast<unsigned>(Lines + 1), |
| static_cast<unsigned>(Offset - StartOfLine + 1)}; |
| } |
| |
| CompletionContext runCompletion(StringRef Code, size_t Offset) { |
| CompletionContext ResultCtx; |
| clang::tooling::runToolOnCodeWithArgs( |
| std::make_unique<CodeCompleteAction>(offsetToPosition(Code, Offset), |
| ResultCtx), |
| Code, {"-std=c++11"}, TestCCName); |
| return ResultCtx; |
| } |
| |
| CompletionContext runCodeCompleteOnCode(StringRef AnnotatedCode) { |
| llvm::Annotations A(AnnotatedCode); |
| return runCompletion(A.code(), A.point()); |
| } |
| |
| std::vector<std::string> |
| collectPreferredTypes(StringRef AnnotatedCode, |
| std::string *PtrDiffType = nullptr) { |
| llvm::Annotations A(AnnotatedCode); |
| std::vector<std::string> Types; |
| for (size_t Point : A.points()) { |
| auto Results = runCompletion(A.code(), Point); |
| if (PtrDiffType) { |
| assert(PtrDiffType->empty() || *PtrDiffType == Results.PtrDiffType); |
| *PtrDiffType = Results.PtrDiffType; |
| } |
| Types.push_back(Results.PreferredType); |
| } |
| return Types; |
| } |
| |
| TEST(SemaCodeCompleteTest, VisitedNSForValidQualifiedId) { |
| auto VisitedNS = runCodeCompleteOnCode(R"cpp( |
| namespace ns1 {} |
| namespace ns2 {} |
| namespace ns3 {} |
| namespace ns3 { namespace nns3 {} } |
| |
| namespace foo { |
| using namespace ns1; |
| namespace ns4 {} // not visited |
| namespace { using namespace ns2; } |
| inline namespace bar { using namespace ns3::nns3; } |
| } // foo |
| namespace ns { foo::^ } |
| )cpp") |
| .VisitedNamespaces; |
| EXPECT_THAT(VisitedNS, UnorderedElementsAre("foo", "ns1", "ns2", "ns3::nns3", |
| "foo::(anonymous)")); |
| } |
| |
| TEST(SemaCodeCompleteTest, VisitedNSForInvalidQualifiedId) { |
| auto VisitedNS = runCodeCompleteOnCode(R"cpp( |
| namespace na {} |
| namespace ns1 { |
| using namespace na; |
| foo::^ |
| } |
| )cpp") |
| .VisitedNamespaces; |
| EXPECT_THAT(VisitedNS, UnorderedElementsAre("ns1", "na")); |
| } |
| |
| TEST(SemaCodeCompleteTest, VisitedNSWithoutQualifier) { |
| auto VisitedNS = runCodeCompleteOnCode(R"cpp( |
| namespace n1 { |
| namespace n2 { |
| void f(^) {} |
| } |
| } |
| )cpp") |
| .VisitedNamespaces; |
| EXPECT_THAT(VisitedNS, UnorderedElementsAre("n1", "n1::n2")); |
| } |
| |
| TEST(PreferredTypeTest, BinaryExpr) { |
| // Check various operations for arithmetic types. |
| StringRef Code = R"cpp( |
| void test(int x) { |
| x = ^10; |
| x += ^10; x -= ^10; x *= ^10; x /= ^10; x %= ^10; |
| x + ^10; x - ^10; x * ^10; x / ^10; x % ^10; |
| })cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int")); |
| |
| Code = R"cpp( |
| void test(float x) { |
| x = ^10; |
| x += ^10; x -= ^10; x *= ^10; x /= ^10; x %= ^10; |
| x + ^10; x - ^10; x * ^10; x / ^10; x % ^10; |
| })cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("float")); |
| |
| // Pointer types. |
| Code = R"cpp( |
| void test(int *ptr) { |
| ptr - ^ptr; |
| ptr = ^ptr; |
| })cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int *")); |
| |
| Code = R"cpp( |
| void test(int *ptr) { |
| ptr + ^10; |
| ptr += ^10; |
| ptr -= ^10; |
| })cpp"; |
| { |
| std::string PtrDiff; |
| auto Types = collectPreferredTypes(Code, &PtrDiff); |
| EXPECT_THAT(Types, Each(PtrDiff)); |
| } |
| |
| // Comparison operators. |
| Code = R"cpp( |
| void test(int i) { |
| i <= ^1; i < ^1; i >= ^1; i > ^1; i == ^1; i != ^1; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int")); |
| |
| Code = R"cpp( |
| void test(int *ptr) { |
| ptr <= ^ptr; ptr < ^ptr; ptr >= ^ptr; ptr > ^ptr; |
| ptr == ^ptr; ptr != ^ptr; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int *")); |
| |
| // Relational operations. |
| Code = R"cpp( |
| void test(int i, int *ptr) { |
| i && ^1; i || ^1; |
| ptr && ^1; ptr || ^1; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("_Bool")); |
| |
| // Bitwise operations. |
| Code = R"cpp( |
| void test(long long ll) { |
| ll | ^1; ll & ^1; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("long long")); |
| |
| Code = R"cpp( |
| enum A {}; |
| void test(A a) { |
| a | ^1; a & ^1; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("enum A")); |
| |
| Code = R"cpp( |
| enum class A {}; |
| void test(A a) { |
| // This is technically illegal with the 'enum class' without overloaded |
| // operators, but we pretend it's fine. |
| a | ^a; a & ^a; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("enum A")); |
| |
| // Binary shifts. |
| Code = R"cpp( |
| void test(int i, long long ll) { |
| i << ^1; ll << ^1; |
| i <<= ^1; i <<= ^1; |
| i >> ^1; ll >> ^1; |
| i >>= ^1; i >>= ^1; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int")); |
| |
| // Comma does not provide any useful information. |
| Code = R"cpp( |
| class Cls {}; |
| void test(int i, int* ptr, Cls x) { |
| (i, ^i); |
| (ptr, ^ptr); |
| (x, ^x); |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("NULL TYPE")); |
| |
| // User-defined types do not take operator overloading into account. |
| // However, they provide heuristics for some common cases. |
| Code = R"cpp( |
| class Cls {}; |
| void test(Cls c) { |
| // we assume arithmetic and comparions ops take the same type. |
| c + ^c; c - ^c; c * ^c; c / ^c; c % ^c; |
| c == ^c; c != ^c; c < ^c; c <= ^c; c > ^c; c >= ^c; |
| // same for the assignments. |
| c = ^c; c += ^c; c -= ^c; c *= ^c; c /= ^c; c %= ^c; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("class Cls")); |
| |
| Code = R"cpp( |
| class Cls {}; |
| void test(Cls c) { |
| // we assume relational ops operate on bools. |
| c && ^c; c || ^c; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("_Bool")); |
| |
| Code = R"cpp( |
| class Cls {}; |
| void test(Cls c) { |
| // we make no assumptions about the following operators, since they are |
| // often overloaded with a non-standard meaning. |
| c << ^c; c >> ^c; c | ^c; c & ^c; |
| c <<= ^c; c >>= ^c; c |= ^c; c &= ^c; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("NULL TYPE")); |
| } |
| |
| TEST(PreferredTypeTest, Members) { |
| StringRef Code = R"cpp( |
| struct vector { |
| int *begin(); |
| vector clone(); |
| }; |
| |
| void test(int *a) { |
| a = ^vector().^clone().^begin(); |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int *")); |
| } |
| |
| TEST(PreferredTypeTest, Conditions) { |
| StringRef Code = R"cpp( |
| struct vector { |
| bool empty(); |
| }; |
| |
| void test() { |
| if (^vector().^empty()) {} |
| while (^vector().^empty()) {} |
| for (; ^vector().^empty();) {} |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("_Bool")); |
| } |
| |
| TEST(PreferredTypeTest, InitAndAssignment) { |
| StringRef Code = R"cpp( |
| struct vector { |
| int* begin(); |
| }; |
| |
| void test() { |
| const int* x = ^vector().^begin(); |
| x = ^vector().^begin(); |
| |
| if (const int* y = ^vector().^begin()) {} |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("const int *")); |
| } |
| |
| TEST(PreferredTypeTest, UnaryExprs) { |
| StringRef Code = R"cpp( |
| void test(long long a) { |
| a = +^a; |
| a = -^a |
| a = ++^a; |
| a = --^a; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("long long")); |
| |
| Code = R"cpp( |
| void test(int a, int *ptr) { |
| !^a; |
| !^ptr; |
| !!!^a; |
| |
| a = !^a; |
| a = !^ptr; |
| a = !!!^a; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("_Bool")); |
| |
| Code = R"cpp( |
| void test(int a) { |
| const int* x = &^a; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("const int")); |
| |
| Code = R"cpp( |
| void test(int *a) { |
| int x = *^a; |
| int &r = *^a; |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("int *")); |
| |
| Code = R"cpp( |
| void test(int a) { |
| *^a; |
| &^a; |
| } |
| |
| )cpp"; |
| } |
| |
| TEST(PreferredTypeTest, ParenExpr) { |
| StringRef Code = R"cpp( |
| const int *i = ^(^(^(^10))); |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("const int *")); |
| } |
| |
| TEST(PreferredTypeTest, FunctionArguments) { |
| StringRef Code = R"cpp( |
| void foo(const int*); |
| |
| void bar(const int*); |
| void bar(const int*, int b); |
| |
| struct vector { |
| const int *data(); |
| }; |
| void test() { |
| foo(^(^(^(^vec^tor^().^da^ta^())))); |
| bar(^(^(^(^vec^tor^().^da^ta^())))); |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("const int *")); |
| |
| Code = R"cpp( |
| void bar(int, volatile double *); |
| void bar(int, volatile double *, int, int); |
| |
| struct vector { |
| double *data(); |
| }; |
| |
| struct class_members { |
| void bar(int, volatile double *); |
| void bar(int, volatile double *, int, int); |
| }; |
| void test() { |
| bar(10, ^(^(^(^vec^tor^().^da^ta^())))); |
| class_members().bar(10, ^(^(^(^vec^tor^().^da^ta^())))); |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("volatile double *")); |
| |
| Code = R"cpp( |
| namespace ns { |
| struct vector { |
| }; |
| } |
| void accepts_vector(ns::vector); |
| |
| void test() { |
| accepts_vector(^::^ns::^vector()); |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("ns::vector")); |
| |
| Code = R"cpp( |
| template <class T> |
| struct vector { using self = vector; }; |
| |
| void accepts_vector(vector<int>); |
| int foo(int); |
| |
| void test() { |
| accepts_vector(^::^vector<decltype(foo(1))>::^self); |
| } |
| )cpp"; |
| EXPECT_THAT(collectPreferredTypes(Code), Each("vector<int>")); |
| } |
| } // namespace |