llvm/llvm-project

[clang] warn on operator in macro expansion whose operand doesn't lie entirely within the same macro expansion

Open

#184672 opened on Mar 4, 2026

View on GitHub
 (4 comments) (0 reactions) (0 assignees)C++ (26,378 stars) (10,782 forks)batch import
clang:diagnosticsgood first issue

Description

Testcase:

#define FOO 2+3
// 2+(3*4) == 14, not (2+3)*4 == 20
int n = FOO*4;

Clang doesn't warn on this, but I think it should. In general, I think a good heuristic would be: if the location of an operator is within a macro expansion, and an operand of that operator is not entirely within that same macro expansion, then warn. In this case, the + operator within FOO has an operand that extends to the 4 token, so we should warn.

This seems like something we could quickly and easily check for with our existing source location representation.

Contributor guide

Tech stack
cpp
Domain
tooling
Issue type
feature
DifficultyEstimated implementation difficulty for a new contributor, from 1 for very small changes to 5 for expert-level work.
2
Estimated timeA rough time range for an experienced contributor to investigate, implement, test, and prepare a pull request.
1-3 hours
Activity statusHow available the issue appears right now: fresh, active, stale, blocked, or waiting on maintainer input.
fresh
ClarityHow clearly the issue explains the expected change, acceptance criteria, and next step.
clear
Prerequisites
C++ programmingClang/LLVM basicsMacro expansion concepts
Newbie friendlinessA 1-100 score estimating how approachable this issue is for first-time contributors.
70
Research direction
The issue describes a heuristic for warning when an operator inside a macro expansion has an operand that extends outside that expansion. To implement, start by understanding clang's source location representation for macro expansions (see SourceManager and MacroExpansion). Look into existing diagnostics in lib/Sema or lib/Analysis that check macro related patterns, such as Wuninitialized or Wtautological undefined compare. The key is to detect when an operator's location is within a macro expansion and any of its operand's locations are not. This likely involves modifying the expression evaluation or adding a check in SemaExpr.cpp. The test case provided can be used to verify the warning.