llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Stefan Gränitz (weliveindetail) <details> <summary>Changes</summary> Reduce code bloat by checking test requirements in a common test fixture --- Patch is 26.02 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/93816.diff 5 Files Affected: - (modified) clang/unittests/Interpreter/CodeCompletionTest.cpp (+76-157) - (modified) clang/unittests/Interpreter/IncrementalProcessingTest.cpp (+5-16) - (modified) clang/unittests/Interpreter/InterpreterExtensionsTest.cpp (+27-38) - (modified) clang/unittests/Interpreter/InterpreterTest.cpp (+16-84) - (added) clang/unittests/Interpreter/InterpreterTestFixture.h (+67) ``````````diff diff --git a/clang/unittests/Interpreter/CodeCompletionTest.cpp b/clang/unittests/Interpreter/CodeCompletionTest.cpp index 72c02c683fafd..89a86a5391627 100644 --- a/clang/unittests/Interpreter/CodeCompletionTest.cpp +++ b/clang/unittests/Interpreter/CodeCompletionTest.cpp @@ -1,3 +1,17 @@ +//===- unittests/Interpreter/CodeCompletionTest.cpp -----------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// +// +// Unit tests for Clang's Interpreter library. +// +//===----------------------------------------------------------------------===// + +#include "InterpreterTestFixture.h" + #include "clang/Interpreter/CodeCompletion.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Interpreter/Interpreter.h" @@ -12,132 +26,86 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" -#if defined(_AIX) || defined(__MVS__) -#define CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -#endif - 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 {}; +class CodeCompletionTest : public InterpreterTestBase { +public: + std::unique_ptr<CompilerInstance> CI; + std::unique_ptr<Interpreter> Interp; + + CodeCompletionTest() : CI(cantFail(CB.CreateCpp())), Interp(cantFail(clang::Interpreter::create(std::move(CI)))) {} + + std::vector<std::string> runComp(llvm::StringRef Input, + llvm::Error &ErrR) { + auto ComplCI = CB.CreateCpp(); + if (auto Err = ComplCI.takeError()) { + ErrR = std::move(Err); + return {}; + } + + auto ComplInterp = clang::Interpreter::create(std::move(*ComplCI)); + if (auto Err = ComplInterp.takeError()) { + ErrR = std::move(Err); + return {}; + } + + std::vector<std::string> Results; + std::vector<std::string> Comps; + auto *ParentCI = this->Interp->getCompilerInstance(); + auto *MainCI = (*ComplInterp)->getCompilerInstance(); + auto CC = ReplCodeCompleter(); + CC.codeComplete(MainCI, Input, /* Lines */ 1, Input.size() + 1, + ParentCI, Results); + + for (auto Res : Results) + if (Res.find(CC.Prefix) == 0) + Comps.push_back(Res); + return Comps; } +}; - 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; -} - -static bool HostSupportsJit() { - auto J = llvm::orc::LLJITBuilder().create(); - if (J) - return true; - LLVMConsumeError(llvm::wrap(J.takeError())); - return false; -} - -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_Sanity) { -#else -TEST(CodeCompletionTest, Sanity) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, Sanity) { cantFail(Interp->Parse("int foo = 12;")); auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, "f", Err); + auto comps = runComp("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); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_SanityNoneValid) { -#else -TEST(CodeCompletionTest, SanityNoneValid) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, SanityNoneValid) { cantFail(Interp->Parse("int foo = 12;")); auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, "babanana", Err); + auto comps = runComp("babanana", Err); EXPECT_EQ((size_t)0, comps.size()); // foo and float EXPECT_EQ((bool)Err, false); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_TwoDecls) { -#else -TEST(CodeCompletionTest, TwoDecls) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, TwoDecls) { cantFail(Interp->Parse("int application = 12;")); cantFail(Interp->Parse("int apple = 12;")); auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, "app", Err); + auto comps = runComp("app", Err); EXPECT_EQ((size_t)2, comps.size()); EXPECT_EQ((bool)Err, false); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_CompFunDeclsNoError) { -#else -TEST(CodeCompletionTest, CompFunDeclsNoError) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, CompFunDeclsNoError) { auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, "void app(", Err); + auto comps = runComp("void app(", Err); EXPECT_EQ((bool)Err, false); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_TypedDirected) { -#else -TEST(CodeCompletionTest, TypedDirected) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, TypedDirected) { 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); + auto comps = runComp(std::string("add("), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ((bool)Err, false); } @@ -146,7 +114,7 @@ TEST(CodeCompletionTest, TypedDirected) { { auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, std::string("add("), Err); + auto comps = runComp(std::string("add("), Err); EXPECT_EQ((size_t)2, comps.size()); EXPECT_EQ(comps[0], "application"); EXPECT_EQ(comps[1], "banana"); @@ -155,21 +123,14 @@ TEST(CodeCompletionTest, TypedDirected) { { auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, std::string("add(b"), Err); + auto comps = runComp(std::string("add(b"), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ(comps[0], "banana"); EXPECT_EQ((bool)Err, false); } } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_SanityClasses) { -#else -TEST(CodeCompletionTest, SanityClasses) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, SanityClasses) { cantFail(Interp->Parse("struct Apple{};")); cantFail(Interp->Parse("void takeApple(Apple &a1){}")); cantFail(Interp->Parse("Apple a1;")); @@ -177,107 +138,72 @@ TEST(CodeCompletionTest, SanityClasses) { { auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, "takeApple(", Err); + auto comps = runComp("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); + auto comps = runComp(std::string("takeAppleCopy("), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ(comps[0], std::string("a1")); EXPECT_EQ((bool)Err, false); } } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_SubClassing) { -#else -TEST(CodeCompletionTest, SubClassing) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, SubClassing) { 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); + auto comps = runComp(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); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_MultipleArguments) { -#else -TEST(CodeCompletionTest, MultipleArguments) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, MultipleArguments) { 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); + auto comps = runComp(std::string("takeTwo(foo, "), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ(comps[0], std::string("fowl")); EXPECT_EQ((bool)Err, false); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_Methods) { -#else -TEST(CodeCompletionTest, Methods) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, Methods) { 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); + auto comps = runComp(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); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_MethodsInvocations) { -#else -TEST(CodeCompletionTest, MethodsInvocations) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, MethodsInvocations) { 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); + auto comps = runComp(std::string("f1.add("), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ(comps[0], std::string("a")); EXPECT_EQ((bool)Err, false); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_NestedInvocations) { -#else -TEST(CodeCompletionTest, NestedInvocations) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, NestedInvocations) { cantFail(Interp->Parse( "struct Foo{int add(int a){return 42;} int par(int b){return 42;}};")); cantFail(Interp->Parse("Foo f1;")); @@ -285,26 +211,19 @@ TEST(CodeCompletionTest, NestedInvocations) { 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); + auto comps = runComp(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); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(CodeCompletionTest, DISABLED_TemplateFunctions) { -#else -TEST(CodeCompletionTest, TemplateFunctions) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - auto Interp = createInterpreter(); +TEST_F(CodeCompletionTest, TemplateFunctions) { 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); + auto comps = runComp(std::string("id<int>("), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ(comps[0], std::string("apple")); EXPECT_EQ((bool)Err, false); @@ -315,7 +234,7 @@ TEST(CodeCompletionTest, TemplateFunctions) { cantFail(Interp->Parse("char pear = '4';")); { auto Err = llvm::Error::success(); - auto comps = runComp(*Interp, std::string("pickFirst(apple, "), Err); + auto comps = runComp(std::string("pickFirst(apple, "), Err); EXPECT_EQ((size_t)1, comps.size()); EXPECT_EQ(comps[0], std::string("apple")); EXPECT_EQ((bool)Err, false); diff --git a/clang/unittests/Interpreter/IncrementalProcessingTest.cpp b/clang/unittests/Interpreter/IncrementalProcessingTest.cpp index 732753f11306e..1abf5ad222879 100644 --- a/clang/unittests/Interpreter/IncrementalProcessingTest.cpp +++ b/clang/unittests/Interpreter/IncrementalProcessingTest.cpp @@ -6,6 +6,8 @@ // //===----------------------------------------------------------------------===// +#include "InterpreterTestFixture.h" + #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/RecursiveASTVisitor.h" @@ -36,6 +38,8 @@ using namespace clang; namespace { +class IncrementalProcessingTest : public InterpreterTestBase {}; + // Incremental processing produces several modules, all using the same "main // file". Make sure CodeGen can cope with that, e.g. for static initializers. const char TestProgram1[] = "extern \"C\" int funcForProg1() { return 17; }\n" @@ -56,22 +60,7 @@ const Function *getGlobalInit(llvm::Module *M) { return nullptr; } -static bool HostSupportsJit() { - auto J = llvm::orc::LLJITBuilder().create(); - if (J) - return true; - LLVMConsumeError(llvm::wrap(J.takeError())); - return false; -} - -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(IncrementalProcessing, DISABLED_EmitCXXGlobalInitFunc) { -#else -TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) { -#endif - if (!HostSupportsJit()) - GTEST_SKIP(); - +TEST_F(IncrementalProcessingTest, EmitCXXGlobalInitFunc) { std::vector<const char *> ClangArgv = {"-Xclang", "-emit-llvm-only"}; auto CB = clang::IncrementalCompilerBuilder(); CB.SetCompilerArgs(ClangArgv); diff --git a/clang/unittests/Interpreter/InterpreterExtensionsTest.cpp b/clang/unittests/Interpreter/InterpreterExtensionsTest.cpp index e22a78048d525..02d4a3c782889 100644 --- a/clang/unittests/Interpreter/InterpreterExtensionsTest.cpp +++ b/clang/unittests/Interpreter/InterpreterExtensionsTest.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include "InterpreterTestFixture.h" + #include "clang/Interpreter/Interpreter.h" #include "clang/AST/Expr.h" @@ -37,34 +39,33 @@ using namespace clang; namespace { -static bool HostSupportsJit() { - auto J = llvm::orc::LLJITBuilder().create(); - if (J) - return true; - LLVMConsumeError(llvm::wrap(J.takeError())); - return false; -} - -// Some tests require a arm-registered-target -static bool IsARMTargetRegistered() { - llvm::Triple TT; - TT.setArch(llvm::Triple::arm); - TT.setVendor(llvm::Triple::UnknownVendor); - TT.setOS(llvm::Triple::UnknownOS); - - std::string UnusedErr; - return llvm::TargetRegistry::lookupTarget(TT.str(), UnusedErr); -} +class InterpreterExtensionsTest : public InterpreterTestBase { +protected: + void SetUp() override { +#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT + GTEST_SKIP(); +#endif + } -struct LLVMInitRAII { - LLVMInitRAII() { + static void SetUpTestSuite() { llvm::InitializeAllTargets(); llvm::InitializeAllTargetInfos(); llvm::InitializeAllTargetMCs(); llvm::InitializeAllAsmPrinters(); } - ~LLVMInitRAII() { llvm::llvm_shutdown(); } -} LLVMInit; + +public: + // Some tests require a arm-registered-target + static bool IsARMTargetRegistered() { + llvm::Triple TT; + TT.setArch(llvm::Triple::arm); + TT.setVendor(llvm::Triple::UnknownVendor); + TT.setOS(llvm::Triple::UnknownOS); + + std::string UnusedErr; + return llvm::TargetRegistry::lookupTarget(TT.str(), UnusedErr); + } +}; class RecordRuntimeIBMetrics : public Interpreter { struct NoopRuntimeInterfaceBuilder : public RuntimeInterfaceBuilder { @@ -103,12 +104,8 @@ class RecordRuntimeIBMetrics : public Interpreter { NoopRuntimeInterfaceBuilder *RuntimeIBPtr = nullptr; }; -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(InterpreterExtensionsTest, DISABLED_FindRuntimeInterface) { -#else -TEST(InterpreterExtensionsTest, FindRuntimeInterface) { -#endif - if (!HostSupportsJit()) +TEST_F(InterpreterExtensionsTest, FindRuntimeInterface) { + if (!HostSupportsJIT()) GTEST_SKIP(); clang::IncrementalCompilerBuilder CB; @@ -140,11 +137,7 @@ class CustomJBInterpreter : public Interpreter { llvm::Error CreateExecutor() { return Interpreter::CreateExecutor(); } }; -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(InterpreterExtensionsTest, DISABLED_DefaultCrossJIT) { -#else -TEST(InterpreterExtensionsTest, DefaultCrossJIT) { -#endif +TEST_F(InterpreterExtensionsTest, DefaultCrossJIT) { if (!IsARMTargetRegistered()) GTEST_SKIP(); @@ -156,11 +149,7 @@ TEST(InterpreterExtensionsTest, DefaultCrossJIT) { cantFail(std::move(ErrOut)); } -#ifdef CLANG_INTERPRETER_PLATFORM_CANNOT_CREATE_LLJIT -TEST(InterpreterExtensionsTest, DISABLED_CustomCrossJIT) { -#else -TEST(InterpreterExtensionsTest, CustomCrossJIT) { -#endif +TEST_F(InterpreterExtensionsTest, CustomCrossJIT) { if (!IsARMTargetRegistered()) GTEST_SKIP(); diff --git a/clang/unittests/Interpreter/InterpreterTest.cpp b/clang/unittests/Interpreter/InterpreterTest.cpp index 5294a4bce1ace..3b07d6d1cf5d2 100644 --- a/clang/unittests/Interpreter/InterpreterTest.cpp +++ b/clang/unittests/Interpreter/InterpreterTest.cpp @@ -10,6 +10,8 @@ // //===----------------------------------------------------------------------===// +#include "InterpreterTestFixture.h" + #include "clang/Interpreter/Interpreter.h" #include "clang/AST/Decl.h" @@ -30,16 +32,17 @@ using namespace clang; -#if defined(_AIX) -#define CLANG_INTERPRETER_NO_SUPPORT_EXEC -#endif - int Global = 42; // JIT reports symbol not found on Windows without the visibility attribute. REPL_EXTERNAL_VISIBILITY int getGlobal() { return Global; } REPL_EXTERNAL_VISIBILITY void setGlobal(int val) { Global = val; } namespace { + +class InterpreterTest : public InterpreterTestBase { + // TODO: Collect common variables and utility functions here +}; + using Args = std::vector<const char *>; static std::unique_ptr<Interpreter> createInterpreter(const Args &ExtraArgs = {}, @@ -54,34 +57,11 @@ createInterpreter(const Args &ExtraArgs = {}, return cantFail(clang::Interpreter::create(std::move(CI))); } -static bool HostSupportsJit() { - auto J = llvm::orc::LLJITBuilder().create(); - if (J) - return true; - LLVMConsumeError(llvm::wrap(J.takeError())); - return false; -} - -struct LLVMInitRAII { - LLVMInitRAII() { - llvm::InitializeNativeTarget(); - llvm::InitializeNativeTargetAsmPrinter(); - } - ~LLVMInitRAII() { llvm::llvm_shutdown(); } -} LLVMInit; - static size_t DeclsSize(TranslationUnitDecl *PTUDecl) { return std::distance(PTUDecl->decls().begin(), PTUDecl->decls().end()); } -#ifdef CLANG_INTERPRETER_NO_SUPPORT_EXEC -TEST(InterpreterTest, DISABLED_Sanity) { -#else -TEST(InterpreterTest, Sanity) { -#endif - if (!HostSupportsJit()) - GTES... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/93816 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
