Duplicate definitions are dropped

[maleadt]

I'm trying to wrap a header that has definitions like:

#define foo foo
int foo();

The definition for int foo() is never generated, because of the macro definition. Is there any way to avoid this?

[Gnimuc]

There is no trivial way to avoid this.

The following workaround ignores all macros:

julia> using Clang.LibClang

julia> function Clang.parse_header!(ctx::AbstractContext, header::AbstractString, args)
           flags = CXTranslationUnit_SkipFunctionBodies
           push!(ctx.trans_units, parse_header(ctx.index, header, args, flags))
           return ctx
       end

julia> function Clang.parse_headers!(ctx::AbstractContext, headers::Vector{<:AbstractString}, args)
           flags = CXTranslationUnit_SkipFunctionBodies
           tus = parse_headers(ctx.index, headers, args, flags)
               append!(ctx.trans_units, tus)
           return ctx
       end

julia> using Clang.Generators

julia> ctx = create_context("test.h", get_default_args())
       
julia> build!(ctx)
[ Info: Processing header: test.h
[ Info: Building the DAG...
[ Info: Emit Julia expressions...
┌ Warning: No Prototype for CLCursor (CLFunctionDecl) foo() - assuming no arguments
└ @ Clang.Generators C:\Users\yupei.qi\.julia\dev\Clang\src\generator\codegen.jl:128
# no prototype is found for this function at test.h:2:5, please use with caution
function foo()
    ccall((:foo, libclang), Cint, ())
end

[ Info: Done!
Context(...)

But it's not easy to add support for both non-macro identifiers and macro identifiers.

I'm wondering why people use macros like this. Is it generated by AI?

[maleadt]

Skipping all macros isn't an option...

I'm wondering why people use macros like this. Is it generated by AI?

No, it's for an upcoming version change. So CUDA has headers that do:

#define foo foo_v2

int foo_v2(...);

They do this so that you can use the foo symbol in source code, while actually linking against foo_v2, which allows them to version APIs (in the future they'll introduce foo_v3 and have users that recompile use that function, while retaining binary compatibility with users that use foo_v2. pretty neat).

However, in that section they have some unneeded placeholders for upcoming changes, leading to #define foo foo that will later be changed to #define foo foo_v2. It's annoying, but not illegal, so I guess we should be able to handle that one way or another.

Is there a way to only ignore specific macros? (the current ignore mechanism applies to everything)?

[Gnimuc]

However, in that section they have some unneeded placeholders for upcoming changes, leading to #define foo foo that will later be changed to #define foo foo_v2.

😫

Is there a way to only ignore specific macros? (the current ignore mechanism applies to everything)?

I believe it would be easier to ignore this pattern(if a macro is constant-definition-like, and the two identifiers are exactly the same, then we ignore it in the top-level node collection pass).

[maleadt]

I believe it would be easier to ignore this pattern(if a macro is constant-definition-like, and the two identifiers are exactly the same, then we ignore it in the top-level node collection pass).

Yeah that sounds like it would work too. A little specific, but I won't complain :-)

[maleadt]

I finally got to implementing this:

# a pass that removes macro definitions that are also function definitions.
#
# this sometimes happens with NVIDIA's headers, either because of typos, or because they are
# reserving identifiers for future use:
#   #define cuStreamGetCaptureInfo_v2 __CUDA_API_PTSZ(cuStreamGetCaptureInfo_v2)
mutable struct AvoidDuplicates <: Clang.AbstractPass end
function (x::AvoidDuplicates)(dag::ExprDAG, options::Dict)
    # collect macro definitions
    macro_definitions = Dict()
    for (i, node) in enumerate(dag.nodes)
        if node isa ExprNode{<:AbstractMacroNodeType}
            macro_definitions[node.id] = (i, node)
        end
    end

    # scan function definitions
    for (i, node) in enumerate(dag.nodes)
        if Generators.is_function(node) && !Generators.is_variadic_function(node)
            if haskey(macro_definitions, node.id)
                @info "Removing macro definition for $(node.id)"
                j, duplicate_node  = macro_definitions[node.id]
                dag.nodes[j] = ExprNode(node.id, Clang.Generators.Skip(), duplicate_node.cursor, duplicate_node.exprs, duplicate_node.adj)
            end
        end
    end

    return dag
end

This pass needs to be registered early (before the function definition is marked as a duplicate), so:

insert!(ctx.passes, 2, AvoidDuplicates())