如何在Clang-tidy检查中正确识别变量作用域？

我正在编写一个Clang-tidy检查器，用于检测同一作用域中是否已存在相似命名的变量，若存在则发出警告。比如类中声明int test后，类内函数中再声明int Test时会触发警告，这部分逻辑正常，但无法正确处理以下场景：

class testclass
{
    private:
    int avocado;
    void banana()
    {
        if(avocado == 0)
        {
            int orange = 1;
        }

        if(avocado == 2)
        {
            int Orange = 5;
            // 此处不应触发警告，但当前代码却发出了警告
        }
        
    }
};

当前检查器会把两个if代码块判定为同一作用域，但实际上这两个变量彼此不可见。以下是我当前的检查代码：

const DeclContext *Context = nullptr;

const auto *Var = Result.Nodes.getNodeAs<DeclaratorDecl>("variable");
//binding all variables from functions here
if(Var)
{
    Context = Var->getDeclContext();
}

const auto *Field = Result.Nodes.getNodeAs<DeclaratorDecl>("field");
//binding all variables from classes here
if(Field)
{
    Context = Field->getDeclContext();
}

while (Context)
{
    for (const auto *Decl : Context->decls())
    {
        // check whether current variable is already declared in the same scope
        if (const auto *PreviousVar = dyn_cast<VarDecl>(Decl))
        {
            if(PreviousVar == Var)
            {
                continue;
            }

            CheckforEquality(Var, PreviousVar);
            CheckforEquality(Field, PreviousVar);
        }

        if (const auto *PreviousField = dyn_cast<FieldDecl>(Decl))
        {
            if(PreviousField == Field)
            {
                continue;
            }

            CheckforEquality(Var, PreviousField);
            CheckforEquality(Field, PreviousField);
        }
    }
    Context = Context->getParent();
}

不知道该怎么修改代码，让不同if块的变量不被判定为同一作用域，有没有准确判断变量是否处于同一作用域的方法？

问题核心是错误遍历了当前上下文的所有声明，没考虑作用域嵌套可见性规则——不同if块属于独立子作用域，变量互相不可见，但现有逻辑会把父作用域（函数banana）下的所有子作用域声明拉出来检查，导致误判。

可以通过以下方法修复：

1. 用DeclContext::lookup查询可见符号 #

Clang的DeclContext提供的lookup方法，会自动处理嵌套作用域的遮蔽规则，只返回当前作用域实际可见的符号，不会包含其他子作用域的不可见变量。

修改思路：

• 获取当前变量的标识符IdentifierInfo
• 调用当前上下文的lookup方法查询可见声明
• 对查询结果执行相似命名检查（比如大小写不匹配的情况）

2. 区分作用域类型，避免遍历子作用域声明 #

之前的Context->decls()会返回当前上下文下的所有声明，包括所有子作用域的变量，这是误判根源。改用lookup后，只会返回可见变量，自然不会包含其他if块的变量。

核心代码示例：

if (auto *Var = Result.Nodes.getNodeAs<VarDecl>("variable")) {
    const DeclContext *CurrentCtx = Var->getDeclContext();
    IdentifierInfo *VarId = Var->getIdentifier();
    if (!VarId) return;

    // 查询当前作用域的可见变量
    LookupResult Lookup(Var->getASTContext(), VarId, Var->getLocation(), Sema::LookupOrdinaryName);
    CurrentCtx->lookup(Lookup);

    for (const auto *FoundDecl : Lookup) {
        if (FoundDecl == Var) continue;
        if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
            CheckforEquality(Var, FoundVar);
        }
    }

    // 遍历父作用域，检查类成员等上层可见变量
    const DeclContext *ParentCtx = CurrentCtx->getParent();
    while (ParentCtx) {
        LookupResult ParentLookup(Var->getASTContext(), VarId, Var->getLocation(), Sema::LookupOrdinaryName);
        ParentCtx->lookup(ParentLookup);
        for (const auto *FoundDecl : ParentLookup) {
            if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
                CheckforEquality(Var, FoundField);
            }
        }
        ParentCtx = ParentCtx->getParent();
    }
}

// FieldDecl的检查逻辑类似，此处省略

3. 处理大小写不敏感的相似命名 #

如果需要检查大小写不同的相似命名，不能直接用lookup的精确匹配，可按以下方式处理：

• 遍历当前作用域及父作用域的直接声明（跳过子作用域）
• 对每个声明的标识符进行大小写不敏感的字符串比较
• 用isa<CompoundStmt>(Ctx)、isa<FunctionDecl>(Ctx)等判断作用域类型，确保只处理目标层级的声明

内容的提问来源于stack exchange，提问作者sophie