Clang AST matcher for variables compared to different variable types

Question

I am new to clang-tidy and the following is practice so I can move to more complex matchers and tools.

Lets say we have

typedef int my_type;
void foo()
{
       int x = 0;//this should be identified as need to be fixed
       my_type z = 0;
       if( x == z){
               //match this case
       }

}

My goal is to identify variables that are compared against "my_type" in order to fix their declarations by changing their types to my_type.

Right now I am tryng to do the following

     auto my_type_decl = varDecl(hasType(asString("my_type")));
     auto my_type_decl_exp= declRefExpr(to(my_type_decl));
     auto binop = binaryOperator(has(implicitCastExpr(has(my_type_decl_exp))));
     auto other_decl_exp = declRefExpr(hasAncestor(binop), unless(to(my_type_decl)));
     //get ancestor functionDecl
     //get descendant varDecls that match the other_decl_exp

The problem here is that I disregard context. What would be the correct way to go about something like this?

@Mark The way I am trying to achieve this will ultimately change all "int x;" to "my_type x;" in function foo. But more "int x;" could exist within the foo function and not all of them may need to be changed. In short, is there any way to avoid the ancestor matcher and got straight from the DeclRefExpr to the variable declaration? — warz, Dec 19 '19 at 08:40

score 3 · Accepted Answer · answered Dec 19 '19 at 09:23

You can bind node matchers to a name, and then retrieve those nodes from the match result.

For example:

// Match binary operators
binaryOperator(
    // that are equality comparisons,
    hasOperatorName("=="),
    // where one side refers to a variable
    hasEitherOperand(ignoringImpCasts(declRefExpr(to(varDecl(
        // whose type is a typedef or type alias
        hasType(typedefNameDecl(
            // named "::my_type"
            hasName("::my_type"),
            // that aliases any type, which is bound to the name "aliased",
            hasType(type().bind("aliased"))))))))),
    // and where one side refers to a variable
    hasEitherOperand(ignoringImpCasts(declRefExpr(to(varDecl(
        // whose type is the same as the type bound to "aliased",
        // which is bound to the name "declToChange".
        hasType(type(equalsBoundNode("aliased")))).bind("declToChange"))))));

And then:

const auto *declToChange = result.Nodes.getNodeAs<VarDecl>("declToChange");

Note that this matches the equality comparisons, so declToChange might point to the same VarDecl in multiple matches.

In the following example, this matcher would produce two matches with declToChange bound to x, and none with declToChange bound to y:

typedef int my_type;

void foo() {
  int x = 0;
  int y = 0;
  my_type z = 0;

  if (x == z) {
  }

  if (z == x) {
  }
}

Thank you for also demonstrating a more correct approach. Maybe my example was a bad one but I guess the `type(equalsBoundNode("aliased")))` is not needed. 'my_type' could be size_t for instance. Nevertheless, it covers my question. — warz, Dec 19 '19 at 11:00

Clang AST matcher for variables compared to different variable types

1 Answers1