[cfe-dev] Source information for types

[Enea Zaffanella]

Hello.

Argyrios Kyrtzidis wrote:
> Hi clang community,
> 
> I'd like to make a proposal for keeping source location information  
> for types in the AST, to allow functionality like "find the source  
> locations where this typedef is used".
[...snip...]
> TypeSpecifier will replace the QualType fields in the Decls. For  
> example, ValueDecl will contain a TypeSpecifier instead of a plain  
> QualType.
> "QualType ValueDecl::getType()" will delegate to TypeSpecifier::getType 
> () (ValueDecl::getType() will still return a QualType).
> TypeSpecifier will also be contained in Exprs that deal with type- 
> specifiers, like SizeOfAlignOfExpr.
[...]

As clang users, we would be really interested in such a proposal (or a 
functionally equivalent one) and hence we would like to know if there 
have been progresses ... or there are plans in this respect.

Right now, we are facing problems when trying,
e.g., to distinguish the following two cases:

void foo() {
     /* ... */
     int a[sizeof(struct S*)];
     int b[sizeof(struct S {int a;}*)]
     /* ... */
}

from

void bar() {
     /* ... */
     int a[sizeof(struct S {int a;}*)]
     int b[sizeof(struct S*)];
     /* ... */
}

That is, by looking at the AST only it is quite difficult (impossible?) 
to understand whether the `struct S' was defined inside the declaration 
of `a' or that of `b'. Unless I am missing something, both pointer types 
have no associated location info and refer to the very same RecordDecl 
node. Even though the example above doesn't look really interesting, 
variations can be built that are relevant, e.g., for applications that 
need to check strict adherence to user-defined coding standards.

Another issue that could be solved by following this proposal is the 
ability to distinguish different syntactic representations of the same 
type; namely, distinguishing "unsigned" from "unsigned int" from "int 
unsigned" and the like.

As yet another example, we would like to be able to distinguish between
   void (*pf)(int left_is_array[], int* right_is_pointer);
vs
   void (*pf)(int* left_is_pointer, int right_is_array[]);

[Note: since pf is a pointer to function, there are no parameters, hence 
we cannot keep track of the parameter names nor we can retrieve the 
original type from OriginalParmVarDecl].

In our opinion, re-lexing the type specifier is not an option.

Cheers,
Enea Zaffanella.