clang – How to get the type of an expression as a string?

Clang, part of the LLVM project, is a powerful tool for analyzing, transforming, and compiling C, C++, and Objective-C code. When working with Clang’s libraries, you might encounter scenarios where you need to determine the type of an expression as a string. This blog post explains how to achieve this using Clang’s Abstract Syntax Tree (AST) and related APIs.

Prerequisites

Before diving in, make sure you have:

1. Clang libraries installed on your system.
2. Basic familiarity with Clang’s AST and tools like clang::ASTContext, clang::Expr, and clang::QualType.

If you’re new to Clang, consider exploring its documentation and experimenting with its command-line tools, like clang-check or clang-query.

Step 1: Set Up Your Clang Tooling

To interact with Clang’s AST, you’ll typically use the LibTooling API. Start by creating a simple Clang-based tool using the clang::FrontendAction and clang::ASTConsumer classes. For example:

#include <clang/AST/AST.h>
#include <clang/AST/RecursiveASTVisitor.h>
#include <clang/Frontend/FrontendAction.h>
#include <clang/Frontend/CompilerInstance.h>
#include <clang/Tooling/Tooling.h>

using namespace clang;

class TypeExtractorVisitor : public RecursiveASTVisitor<TypeExtractorVisitor> {
public:
explicit TypeExtractorVisitor(ASTContext &Context) : Context(Context) {}

bool VisitExpr(Expr *E) {
QualType T = E->getType();
llvm::outs() << “Expression Type: ” << T.getAsString() << “\n”;
return true;
}

private:
ASTContext &Context;
};

class TypeExtractorConsumer : public ASTConsumer {
public:
explicit TypeExtractorConsumer(ASTContext &Context) : Visitor(Context) {}

void HandleTranslationUnit(ASTContext &Context) override {
Visitor.TraverseDecl(Context.getTranslationUnitDecl());
}

private:
TypeExtractorVisitor Visitor;
};

class TypeExtractorAction : public ASTFrontendAction {
public:
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, StringRef File) override {
return std::make_unique<TypeExtractorConsumer>(CI.getASTContext());
}
};

int main(int argc, const char **argv) {
if (argc > 1) {
clang::tooling::runToolOnCode(std::make_unique<TypeExtractorAction>(), argv[1]);
}
return 0;
}

Step 2: Understand the Key Components

1. QualType: This represents a qualified type in Clang. It provides methods like getAsString() to retrieve the string representation of the type.
2. Expr: This represents an expression node in the AST. The getType() method returns a QualType representing the type of the expression.
3. RecursiveASTVisitor: This utility simplifies traversing the AST, letting you focus on specific node types, like Expr.

Step 3: Compile and Test Your Tool

Save the above code in a file (e.g., TypeExtractor.cpp) and compile it using:

g++ TypeExtractor.cpp -o TypeExtractor \
`llvm-config –cxxflags –ldflags –system-libs –libs clang`

Run your tool with a test input:

./TypeExtractor “int x = 42; x + 1;”

This should output the type of the expression:

Expression Type: int

Notes on getAsString()

The QualType::getAsString() method provides a human-readable representation of the type. However, in some cases, you may want more detailed information, such as:

• Canonical Type: Use T.getCanonicalType().getAsString() to get the canonical (unqualified) type.
• Type Desugarization: For typedefs, you can resolve the underlying type using T.getDesugaredType(Context).

Clang’s AST APIs provide a straightforward way to extract and manipulate type information. With tools like QualType, you can analyze and transform code effectively. The example here serves as a foundation for more advanced analyses, such as custom linting or code refactoring tools.

Happy coding!