How do I find the SourceLocation of the commas between function arguments using libtooling?

user_3286416 0
Viewed 380

My main goal is trying to get macros (or even just the text) before function parameters. For example:

void Foo(_In_ void* p, _Out_ int* x, _Out_cap_(2) int* y);

I need to gracefully handle things like macros that declare parameters (by ignoring them).

#define Example _In_ int x void Foo(Example);

I've looked at Preprocessor record objects and used Lexer::getSourceText to get the macro names In, Out, etc, but I don't see a clean way to map them back to the function parameters.

My current solution is to record all the macro expansions in the file and then compare their SourceLocation to the ParamVarDecl SourceLocation. This mostly works except I don't know how to skip over things after the parameter.

void Foo(_In_ void* p _Other_, _In_ int y);

Getting the SourceLocation of the comma would work, but I can't find that anywhere.

abstract-syntax-tree clang llvm
1 Answers

The title of the questions asks for libclang, but as you use Lexer::getSourceText I assume that it's libTooling. The rest of my answer is viable only in terms of libTooling.

Solution 1

Lexer works on the level of tokens. Comma is also a token, so you can take the end location of a parameter and fetch the next token using Lexer::findNextToken.

Here is a ParmVarDecl (for function parameters) and CallExpr (for function arguments) visit functions that show how to use it:

template <class T> void printNextTokenLocation(T *Node) {
  auto NodeEndLocation = Node->getSourceRange().getEnd();

  auto &SM = Context->getSourceManager();
  auto &LO = Context->getLangOpts();

  auto NextToken = Lexer::findNextToken(NodeEndLocation, SM, LO);
  if (!NextToken) {
    return;
  }
  auto NextTokenLocation = NextToken->getLocation();

  llvm::errs() << NextTokenLocation.printToString(SM) << "\n";
}

bool VisitParmVarDecl(ParmVarDecl *Param) {
  printNextTokenLocation(Param);
  return true;
}

bool VisitCallExpr(CallExpr *Call) {
  for (auto *Arg : Call->arguments()) {
    printNextTokenLocation(Arg);
  }
  return true;
}

For the following code snippet:

#define FOO(x) int x
#define BAR float d
#define MINUS -
#define BLANK

void foo(int a, double b     ,
         FOO(c)   , BAR) {}

int main() {
  foo(   42     ,
      36.6 ,   MINUS 10    ,   BLANK 0.0  );
  return 0;
}

it produces the following output (six locations for commas and two for parentheses):

test.cpp:6:15
test.cpp:6:30
test.cpp:7:19
test.cpp:7:24
test.cpp:10:17
test.cpp:11:12
test.cpp:11:28
test.cpp:11:43

This is quite a low-level and error-prone approach though. However, you can change the way you solve the original problem.

Solution 2

Clang stores information about expanded macros in its source locations. You can find related methods in SourceManager (for example, isMacroArgExpansion or isMacroBodyExpansion). As the result, you can visit ParmVarDecl nodes and check their locations for macro expansions.

I would strongly advice moving in the second direction.

I hope this information will be helpful. Happy hacking with Clang!

UPD speaking of attributes, unfortunately, you won't have a lot of choices. Clang does ignore any unknown attribute and this behaviour is not tweakable. If you don't want to patch Clang itself and add your attributes to Attrs.td, then you're limited indeed to tokens and the first approach.

user_115823260
Related