Skip to content

Model pass through behavior of our ArgCaptureAbortIf* support functions #863

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
copybara-service merged 1 commit into from
Apr 23, 2026
Merged

Model pass through behavior of our ArgCaptureAbortIf* support functions #863

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
92 changes: 74 additions & 18 deletions nullability/inference/collect_evidence_test.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -80,10 +80,34 @@ using ::testing::SizeIs;
using ::testing::UnorderedElementsAre;

constexpr llvm::StringRef CheckMacroDefinitions = R"cc(
// Bodies must reference the first param so that args are in the AST, but
// otherwise don't matter.
#define CHECK(X) (X)
#define CHECK_NE(A, B) (A, B)
// A simplified version of Abseil's CHECK macro. We want just enough control
// flow that this should affect flow conditions.
#define CHECK(X) \
if (!X) __builtin_abort();

// A simplified version of Abseil's CHECK_NE (enough to affect flow
// conditions).
struct string;
namespace absl::something {
template <typename T>
const T& GetReferenceableValue(const T& X) {
return X;
}
int GetReferenceableValue(int t) { return t; }

template <typename T1, typename T2>
string* Check_NEImpl(const T1&, const T2&, const char*) {
return nullptr;
}
} // namespace absl::something

#define CHECK_OP(name, op, a, b) \
while (string* result = ::absl::something::name##Impl( \
::absl::something::GetReferenceableValue(a), \
::absl::something::GetReferenceableValue(b), "msg")) \
__builtin_abort();

#define CHECK_NE(a, b) CHECK_OP(Check_NE, !=, (a), (b))
)cc";

constexpr llvm::StringRef GtestMacroDefinitions = R"cc(
Expand Down Expand Up @@ -813,6 +837,22 @@ TEST(SmartPointerCollectEvidenceFromDefinitionTest, CheckMacro) {
evidence(paramSlot(2), Evidence::ABORT_IF_NULL)));
}

TEST(CollectEvidenceFromDefinitionTest, CheckMacroPostState) {
static constexpr llvm::StringRef BaseSrc = R"cc(
Nullable<int*> getOrNull(int x);
int* target() {
int* P = getOrNull(0);
CHECK(P);
return P;
}
)cc";
EXPECT_THAT(
collectFromTargetFuncDefinition((CheckMacroDefinitions + BaseSrc).str()),
UnorderedElementsAre(evidence(SLOT_RETURN_TYPE, Evidence::NONNULL_RETURN),
evidence(Slot(0), Evidence::ASSIGNED_FROM_NULLABLE,
localVarNamed("P"))));
}

// This is a crash repro; see b/370737278.
TEST(SmartPointerCollectEvidenceFromDefinitionTest,
CheckMacroSmartPointerToPointer) {
Expand Down Expand Up @@ -858,12 +898,12 @@ TEST(CollectEvidenceFromDefinitionTest, CheckNEMacro) {
)cc";
EXPECT_THAT(
collectFromTargetFuncDefinition((CheckMacroDefinitions + BaseSrc).str()),
UnorderedElementsAre(evidence(paramSlot(0), Evidence::ABORT_IF_NULL),
evidence(paramSlot(1), Evidence::ABORT_IF_NULL),
evidence(paramSlot(2), Evidence::ABORT_IF_NULL),
evidence(paramSlot(3), Evidence::ABORT_IF_NULL),
evidence(Slot(0), Evidence::ASSIGNED_FROM_NULLABLE,
localVarNamed("A"))));
IsSupersetOf({(evidence(paramSlot(0), Evidence::ABORT_IF_NULL),
evidence(paramSlot(1), Evidence::ABORT_IF_NULL),
evidence(paramSlot(2), Evidence::ABORT_IF_NULL),
evidence(paramSlot(3), Evidence::ABORT_IF_NULL),
evidence(Slot(0), Evidence::ASSIGNED_FROM_NULLABLE,
localVarNamed("A")))}));
}

TEST(SmartPointerCollectEvidenceFromDefinitionTest, CheckNEMacro) {
Expand All @@ -880,15 +920,31 @@ TEST(SmartPointerCollectEvidenceFromDefinitionTest, CheckNEMacro) {
)cc";
EXPECT_THAT(
collectFromTargetFuncDefinition((CheckMacroDefinitions + BaseSrc).str()),
UnorderedElementsAre(evidence(paramSlot(0), Evidence::ABORT_IF_NULL),
evidence(paramSlot(1), Evidence::ABORT_IF_NULL),
evidence(paramSlot(3), Evidence::ABORT_IF_NULL)));
IsSupersetOf({(evidence(paramSlot(0), Evidence::ABORT_IF_NULL),
evidence(paramSlot(1), Evidence::ABORT_IF_NULL),
evidence(paramSlot(3), Evidence::ABORT_IF_NULL))}));
}

TEST(CollectEvidenceFromDefinitionTest, CheckNEMacroPostState) {
static constexpr llvm::StringRef BaseSrc = R"cc(
Nullable<int*> getOrNull(int x);
int* target() {
int* P = getOrNull(0);
CHECK_NE(P, nullptr);
return P;
}
)cc";
EXPECT_THAT(
collectFromTargetFuncDefinition((CheckMacroDefinitions + BaseSrc).str()),
IsSupersetOf({(evidence(SLOT_RETURN_TYPE, Evidence::NONNULL_RETURN),
evidence(Slot(0), Evidence::ASSIGNED_FROM_NULLABLE,
localVarNamed("P")))}));
}

TEST(CollectEvidenceFromDefinitionTest, NullableArgPassed) {
static constexpr llvm::StringRef Src = R"cc(
void callee(int *Q);
void target(Nullable<int *> P) { callee(P); }
void callee(int* Q);
void target(Nullable<int*> P) { callee(P); }
)cc";
EXPECT_THAT(collectFromTargetFuncDefinition(Src),
Contains(evidence(paramSlot(0), Evidence::NULLABLE_ARGUMENT,
Expand Down Expand Up @@ -4418,16 +4474,16 @@ TEST(CollectEvidenceFromDefinitionTest, PragmaLocalTopLevelPointer) {
TEST(CollectEvidenceFromDefinitionTest, PragmaAndMacroReplace) {
static constexpr llvm::StringRef BaseSrc = R"cc(
#pragma nullability file_default nonnull
int* target(NullabilityUnknown<int*> P) {
CHECK(P);
int* target(NullabilityUnknown<int*> P, NullabilityUnknown<int*> Q) {
CHECK(Q);
return P;
}
)cc";
EXPECT_THAT(
collectFromTargetFuncDefinition((CheckMacroDefinitions + BaseSrc).str()),
UnorderedElementsAre(
evidence(paramSlot(0), Evidence::ASSIGNED_TO_NONNULL),
evidence(paramSlot(0), Evidence::ABORT_IF_NULL)));
evidence(paramSlot(1), Evidence::ABORT_IF_NULL)));
}

TEST(CollectEvidenceFromDefinitionTest,
Expand Down
24 changes: 19 additions & 5 deletions nullability/value_transferer.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -910,6 +910,18 @@ static bool isDeclaredInAbseilOrUtil(const Decl& D) {
(NS->getName() == "absl" || NS->getName() == "util");
}

// Models our macro replacement argument-capture functions (supporting
// inference).
static void modelArgCaptureAbortIfPassThrough(const CallExpr& CE,
Environment& Env) {
assert(CE.isGLValue());
assert(CE.getNumArgs() >= 1);
assert(CE.getArg(0) != nullptr);
// Pass through the storage location of the first argument to the result.
if (StorageLocation* Loc = Env.getStorageLocation(*CE.getArg(0)))
Env.setStorageLocation(CE, *Loc);
}

// Models the `GetReferenceableValue` functions used in Abseil logging and
// elsewhere.
static void modelGetReferenceableValue(const CallExpr& CE, Environment& Env) {
Expand Down Expand Up @@ -1019,6 +1031,11 @@ static void transferCallExpr(const CallExpr* absl_nonnull CE,
modelCheckNE(*CE, State.Env);
return;
}
if (FunII->isStr(ArgCaptureAbortIfFalse) ||
FunII->isStr(ArgCaptureAbortIfEqual)) {
modelArgCaptureAbortIfPassThrough(*CE, State.Env);
return;
}
}
}

Expand Down Expand Up @@ -1071,11 +1088,8 @@ static void transferCallExpr(const CallExpr* absl_nonnull CE,

if (CE->isCallToStdMove() || FuncDecl == nullptr) return;

// Don't treat parameters of our macro replacement argument-capture functions
// or of absl::StatusOr::value_or as output parameters.
if (FunII && (FunII->isStr(ArgCaptureAbortIfFalse) ||
FunII->isStr(ArgCaptureAbortIfEqual) ||
(FunII->isStr("value_or") && isMethodOfAbslStatusOr(FuncDecl))))
// Don't treat parameters of absl::StatusOr::value_or as output parameters.
if (FunII && ((FunII->isStr("value_or") && isMethodOfAbslStatusOr(FuncDecl))))
return;
// Make output parameters (with unknown nullability) initialized to unknown.
for (ParamAndArgIterator<CallExpr> Iter(*FuncDecl, *CE); Iter; ++Iter)
Expand Down
Loading