Tool to match defined and used method signatures

Hi All,

I am trying to solve a build contract problem where frequently my dependencies break the contract and my product fails to build.
To prevent this, i wanted to give a contract to my dependencies saying that hey you should not break these methods. Now, you may ask why not simply ask your dependencies to build my package and check, but it takes a long time to build my package, and hence wanted an easy check.

Let’s suppose I establish a contract like this,

int Calculator::add(int, int) is an agreement and my dependency will should not change it,
if he changes this to say,
int Calculator::add(int, int), then my build contract test should fail.

To do that, I should parse the AST of both the packages and extract all the defined and used methods. Once, i have them i can check whether all the methods that i have used has a definition in the dependency AST or not.

Do we have a tooling already on this? wanted to know the right library to use on this as if i had to write this AST comparison from scratch, I should handle inheritance, typedefines and all of such cases.

Not sure if ast matcher would be right here, because I should understand the ast of consumer and create an ast matcher query from the used method and check if it exists in the producer which is round about, than doing a direct check on the method signatures as per the ast of producer and consumer.

Thanks in advance for your help!


Madhura Ganesh


There’s an existing infrastructure called “AST matchers” already available through Clang:
As a gentle introduction, you could look at Tidy checks which mainly (but not exclusively) use these matchers to find constructs.

Custom tools can be created with the libTooling framework, if you want a binary with your own entry point.

When the AST matcher matches, you have the matched AST Node (which have an extensive hierarchy and lots and lots of query functions you can do on them!) in your hand in the match handler.

If you can sketch the problem where the match set is small, you would be better off matching this small set of nodes, and then walking back (you can query the context (namespace, record) of a method, from that you can go to the parent context, for records query their bases, etcc.).

Problem is that executing all these requires a semantically correct source file, otherwise there will be no (sensible) AST on which the matchers can run.

This means that if I have version A which works and version B which is broken in the build, the check(s) will also be broken.
If your checks would only run on the dependencies, you’re safe.

As for the dependencies, to automatically invoke the analysis properly, Clang uses the “JSON Compilation Database” format. You need these “build logs” (build command for the dependency projects!, and potentially an executed build in some cases - e.g. if the project depends on build-generated files) so Clang knows with what flags to run the analysis with.
If you have your own libTooling project (your own binary you call, not clang-tidy), you can have a command-line argument that gets parsed as a compilation database.

Madhura Ganesh via cfe-dev <> ezt írta (időpont: 2020. márc. 21., Szo, 8:58):