Add needsImplicitDefaultConstructor and friends

[anderslanglands]

Summary

Wraps CXXRecord::needsImplicitDefaultConstructor, needsImplicitCopyConstructor, etc.

[anderslanglands]

Fixed clang-format error

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1512–1514

We might want to document that this API may return different results while the record is being formed from after the record is complete. e.g., we may say the defaulted copy constructor is not deleted at the start of the record but later find a data member that causes us to delete the defaulted copy constructor. (Similar for the others.)

1530

I don't think we should expose any of the "needs" functions like this -- those are internal implementation details of the class and I don't think we want to calcify that into something we have to support forever. As we add members to a class, we recalculate whether the added member causes us to delete defaulted special members (among other things), and the "needs" functions are basically used when the class is completed to handle lazily created special members. I'm pretty sure that lazy creation is not mandated by the standard, which is why I think the "needs" functions are more of an implementation detail.

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1530

CC @erichkeane and @royjacobson as folks who have been in this same area of the compiler to see if they agree or disagree with my assessment there.

[royjacobson]

clang/bindings/python/clang/cindex.py

1530

I think so. The 'needs_*' functions query DeclaredSpecialMembers and I'm pretty sure it's modified when we add the implicit definitions in the class completion code. So this looks a bit suspicious. Is this API meant to be used with incomplete classes?
For complete classes I think looking up the default/move/copy constructor and calling isImplicit() is the way to do it.

About the 'is deleted' API - can't the same be done for those functions as well so we have a smaller API?

If this is meant to be used with incomplete classes for efficiency that would be another thing, I guess.

[anderslanglands]

clang/bindings/python/clang/cindex.py

1530

So the intended use case here is I'm using libclang to parse an existing C++ libray's headers and generate a C interface to it. To do that I need to know if I need to generate default constructors etc, which the needs* methods do for me (I believe). The alternative is I have to check manually whether all the constructors/assignment operators exist, then implement the implicit declaration rules myself correctly for each version of the standard, which I'd rather avoid.

Would putting a note in the doc comment about the behaviour differing when the class is being constructed as originally suggested work for everyone?

[royjacobson]

clang/bindings/python/clang/cindex.py

1530

Why is the __is_default_constructible builtin type trait not enough? Do you have different behavior for user provided and implicit default constructors?

[anderslanglands]

clang/bindings/python/clang/cindex.py

1530

Can I evaluate that from libclang somewhow? I can't modify the C++ libraries I'm wrapping.

Basically, given:

struct Foo { /* ... */ };

I want to generate:

typedef struct Foo_t;

Foo_t* Foo_ctor();
Foo_t* Foo_copy_ctor(Foo_t*);
/* etc... */
Foo_dtor(Foo_t*);

In order to know which ones to generate for an arbitrary struct that may or may not have any combination of ctor/assignments defined, I need to know which ones exist and follow the implicit generation rules for the ones that don't. I can do this myself with a whole bunch of version-dependent logic, but I'd rather just rely on libclang since it already knows all this much better than I do.

[royjacobson]

clang/bindings/python/clang/cindex.py

1530

I looked a bit, and it seems they aren't, and that generally libclang doesn't really know about Sema, so exporting the type traits is not that easy :/

I'm not sure what's the best way forward here, but I don't like the idea of exporting those half baked internal API calls when there are actual standardized and implemented type traits that perform the same goal.

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1530

CCing folks who may have more historical memory of the C APIs and whether they're expected to operate on a completed AST or are expected to work on an AST as it is under construction. My unverified belief is that these APIs are expected to work on a completed AST.

@echristo @dblaikie @rjmccall @rsmith

I'm also not certain of what the best path forward is here. I'm not comfortable exposing the needs* functions because they really are implementation details and I don't want to promise we'll support that API forever. But at the same time, the use case is reasonably compelling on the assumption you need to inspect the AST nodes as they're still under construction instead of inspecting them once the AST is completed. If the AST is fully constructed, then we should have already added the AST nodes for any special member functions that needed to be generated implicitly, so as Roy mentioned, you should be able to find the special member function you're after and check isImplicit() on it.

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

Not sure I'm quite following - it doesn't look (admittedly, sorry, at a somewhat superficial look at the discussion here) like this is necessarily about incomplete AST - could parse the header and stop. That's a complete AST, yeah? And then it might be OK/reasonable to ask "could this type be default constructed" (even if the implicit ctor has been implicitly instantiated/there was no use in the source code that's been parsed)

Is that correct?

[anderslanglands]

clang/bindings/python/clang/cindex.py

1530

I am just parsing the headers of a library using clang_parseTranslationUnit() then using clang_visitChildren() to inspect the AST. Doing this I do NOT see any implicitly generated methods, hence why I need these functions. It sounds like you expect those methods to be in the AST already? Which suggests I'm doing something wrong in my parsing (missing another function call/option or something)?

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

Ah, no, I wouldn't expect them to be in the AST unless there was code that used them in the header.

But I'm saying/trying to say is this isn't a "AST nodes still under construction" that @aaron.ballman is describing, so far as I can see - you can completely parse the header, have a complete AST then reasonably want to ask "could I default construct an object like this" - even if the implicit default ctor hasn't been instantiated because none of the parsed code asked that question.

Not sure what the API to do this should look like, but it seems like a pretty reasonable use case.

Not sure about whether they cross some threshold where they're too complex/nuanced to go in the C API or not - maybe that's a question.

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1530

I am just parsing the headers of a library using clang_parseTranslationUnit() then using clang_visitChildren() to inspect the AST. Doing this I do NOT see any implicitly generated methods, hence why I need these functions. It sounds like you expect those methods to be in the AST already? Which suggests I'm doing something wrong in my parsing (missing another function call/option or something)?

Ah, no, I wouldn't expect them to be in the AST unless there was code that used them in the header.

That's part of the "this is an implementation detail" I was talking about. *Today* we don't generate the AST nodes for those functions unless we have to. Nothing says we won't find a reason we need to always generate those AST nodes, which makes the needs* functions useless. I suppose in that situation, the breakage for the C APIs is mostly that the exposed needs* functions start trivially returning false though, so maybe it's not as bad as it could be...

But I'm saying/trying to say is this isn't a "AST nodes still under construction" that @aaron.ballman is describing, so far as I can see - you can completely parse the header, have a complete AST then reasonably want to ask "could I default construct an object like this" - even if the implicit default ctor hasn't been instantiated because none of the parsed code asked that question.

Yeah, the situation I mentioned earlier was the validity of the calls when the class has not been fully constructed in the AST yet. That's not the case here, which is great.

Not sure what the API to do this should look like, but it seems like a pretty reasonable use case.

Agreed that the use case is reasonable.

Not sure about whether they cross some threshold where they're too complex/nuanced to go in the C API or not - maybe that's a question.

Mostly, I think we try to expose APIs that we think we can support long-term based on what needs folks have. Given that there's a need here, and the use case seems reasonable, it seems to be something we should consider supporting.

I suppose there's another way we could view this need though -- some folks need those special member functions even if Clang doesn't think they're necessary to generate. Not only is this use case one such time, but running AST matchers over the AST (like in clang-query or clang-tidy) may also have a similar expectation of finding all the special members. So maybe what we need is some flag to tell Clang "force the generation of those special member functions" so that we don't have to expose a needs function for them (which helps for the C API users but doesn't help folks like consumers of AST matchers). (Note, I don't yet know how good or bad of an idea this is.)

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

Yeah - if someone is interested in doing the work, I'd be curious how some equivalent operations work in the AST matchers? I'd assume there's some way to query if something is copy constructible - and maybe that's more likely to be the query the user wants, rather than the "needs" operations?

(like, if we did add the implicit copy constructors into the AST proactively, I don't think I'd want these queries to return "false" - I think likely the intended query is "is this thing copy constructible" (or similar) less about whether the operation is or isn't present in the AST)

[anderslanglands]

clang/bindings/python/clang/cindex.py

1530

In my case it's "do I need to generate a copy ctor for this type?". @aaron.ballman 's suggestion of a way to force the implicits to be generated in the AST would work just fine for me.

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

In my case it's "do I need to generate a copy ctor for this type?". @aaron.ballman 's suggestion of a way to force the implicits to be generated in the AST would work just fine for me.

But by "generate" you mean "generate a wrapper for this operation", yeah?

If you could query the type for "is this type copy constructible", "is this type copy assignable", etc, be adequate for your needs?

[royjacobson]

clang/bindings/python/clang/cindex.py

1530

That's part of the "this is an implementation detail" I was talking about. *Today* we don't generate the AST nodes for those functions unless we have to. Nothing says we won't find a reason we need to always generate those AST nodes, which makes the needs* functions useless. I suppose in that situation, the breakage for the C APIs is mostly that the exposed needs* functions start trivially returning false though, so maybe it's not as bad as it could be...

...

Yeah, the situation I mentioned earlier was the validity of the calls when the class has not been fully constructed in the AST yet. That's not the case here, which is great.

This is not even about future proofing - this is already bad API. Simply adding

void f() {
  Test t;
}

in the test in this PR is changing the printed line from
ClassDecl=Test:3:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[3:1 - 17:2]
to
ClassDecl=Test:3:7 (Definition) (needs cassign) (needs massign) (needs dtor) Extent=[3:1 - 17:2]

I don't think making functions in libclang conditional on whether somewhere in the headers types are actually used or not is likely to provide value. It's impossible to enforce non-use of a type if it's definition is available and it's very unnatural to C++ to rely on it.

I'm now also pessimistic about the possibility of implementing correct versions of those std::is... type traits without Sema. Default constructors might be template functions that are SFINAE-disabled, for example. This isn't very exotic - the default constructors of pair, optional, etc.. are all implemented like this. The other type traits that we'd want to expose are also pretty similar.

A solution might be useful even if it doesn't handle all cases correctly, of course. But IMHO in this case an approach with only AST would be too partial to justify its shortcomings.

[anderslanglands]

clang/bindings/python/clang/cindex.py

1530

In my case it's "do I need to generate a copy ctor for this type?". @aaron.ballman 's suggestion of a way to force the implicits to be generated in the AST would work just fine for me.

But by "generate" you mean "generate a wrapper for this operation", yeah?

If you could query the type for "is this type copy constructible", "is this type copy assignable", etc, be adequate for your needs?

Thinking about it some more, yes I think it probably would. I would have to do some minor book-keeping to track whether there was one already declared on the class or not, but that's a lot simpler than reimplementing the implicit rules. I guess I would need isDefaultConstructible, isCopyConstructible, isMoveConstructible, isCopyAssignable, and isMoveAssignable

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

@royjacobson it's also going to be pretty problematic to instantiate those templates as members too.

The AST is pretty accurately reflective of the compiler's understanding of the type at the time - adding extra instantiations isn't necessarily an improvement in fidelity. I'd argue it's a loss in fidelity because these things weren't instantiated by the original code.

(types won't be entirely consistent/stable - member function templates are a great example - you can add code that'll cause new instantiations, and there's no way to fully enumerate all possible instantiations. So it's not a goal for a type description to be stable regardless of the code that uses the type)

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1530

To my thinking, there's a difference between "is this copy constructible" and "does this have a copy constructor (even implicitly)". My understanding of what @anderslanglands is trying to do is to find classes that have a special member function so that the wrapper can expose the same functionality. That's not "is this copy constructible", that's "does this have a copy constructor (even implicitly)."

The C++ standard specifies when classes get implicit special member functions and our AST does not reflect that accurately unless the class is being used: https://godbolt.org/z/13h3T3dPq. Both have definition data that accurately reflects whether the class could get those special members (and that definition data is an internal implementation detail), but only one of those classes have AST nodes for the special members, which means trying to run an AST matcher query for every class with a constructor gives unexpected results: https://godbolt.org/z/PhMY57anM

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

Perhaps a simple test: @anderslanglands, if the class had a ctor template that could be used for copying the type - would that meet your requirements? Would you want to write a wrapper that invoked/instantiated that template to perform a copy? Or would you want your wrapper not to expose copy construction?

If it does, then the property of interest is "is this type copy constructible" and not "does this type have a copy constructor", I think?

All that said, I don't outright object to the implicit special members being eagerly generated if it doesn't cost much compile time/memory usage/etc, but I'm certainly a little hesitant. Totally your call, @aaron.ballman

[anderslanglands]

clang/bindings/python/clang/cindex.py

1530

@dblaikie what do you mean by "ctor template" in this context?

note: for "copy ctor" here and in what follows, read "all the potentially implicitly defined functions"

What I'm trying to do is this. I'm essentially transpiling C++ libraries to C (which are then wrapped in Rust, but it could in theory be any other language). I do this by iterating over the AST and extracting all the methods (and all methods from bases), then transforming them into C equivalents. Thus if a class I'm interested in defines a copy ctor itself, my regular AST extraction will generate a C version of that and all is right with the world.

The tricky bit comes when a class *doesnt* define a copy ctor. I then have to figure out if it's not defined because:

1. The library author didn't bother and is relying on it being implicitly defined

or

2. The class *cannot* have a copy ctor because of the implicit rules

In the case of 1) I currently then need to detect this and generate the C version of the copy ctor which calls the (implicitly defined) C++ copy ctor (and of course I'm generating the library that calls this *after* I've extracted the AST, which means I can't rely on this call to define that ctor in the AST).

In the case of 2) I need to detect that and then do nothing (and possibly some other stuff later on if I decide to represent C++ objects as bags of bytes that I pass around but that's another story).

So there a few ways of achieving what I need:

a) I just implement the implicit rules manually, detect what is and isn't there and decide whether to create the copy ctor myself. This is what I did initially, but of course I screwed it up first time which led to me thinking "surely there's a better way".

b) libclang exposes the needs* functions in this patch. I just call those during extraction to decide what I do and do not need to implement manually on the C side. Works perfectly for me, but obviously feels wrong to a few people here.

c) libclang exposes isCopyConstructible() etc. This also works for me, just requires a little more book-keeping my end, i.e. is isCopyConstructible() is true AND the class (or its bases) does not have an explicit copy constructor, I need to generate one.

d) There's some way to force clang to instantiate all the implicit methods in the AST. This would make my life very easy, as I wouldn't have to think about any of this, they'd just be treated like regular methods and everything would just be extracted without any special handling.

So I'd be fine with anything that's not a) :)

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1530

All that said, I don't outright object to the implicit special members being eagerly generated if it doesn't cost much compile time/memory usage/etc, but I'm certainly a little hesitant. Totally your call, @aaron.ballman

Well, I'm hoping we can find a way to avoid doing that in the general case while still giving users a way to opt into that behavior if they need it for the C APIs or AST matching. I think the overhead would be problematic for general compilation (and it would likely impact things like template instantiation depths due to memory overhead pressure), but allowing folks to opt in gives them the power to decide which properties of the compilation are more important to them.

[dblaikie]

clang/bindings/python/clang/cindex.py

1530

@dblaikie what do you mean by "ctor template" in this context?

struct t1 {
  template<typename T>
  t1(const T&) { ... }
};

But actually I got that wrong - the compiler won't consider a template for use when copy constructing.

It does for default constructing, though ( https://godbolt.org/z/hax4jhbPY ):

#include <iostream>
struct t1 {
  template<typename ...Ts>
  t1(Ts ...args) {
      std::cout << "Called the variadic template ctor\n";
  }
};
int main() {
    t1 v2;
}
static_assert(std::is_default_constructible_v<t1>, "");

This type doesn't have a default constructor, but it is default constructible.

So maybe that's a place to ask the question: In this case, which property are you interested in? "has a default constructor" or "is default constructible"? (would you want to write a wrapper around an instantiation of the ctor template taking no args?)

Answering that question might suggest the design for the other implicit ctors/operations, even if they don't have quite the same problems.

Well, I'm hoping we can find a way to avoid doing that in the general case while still giving users a way to opt into that behavior if they need it for the C APIs or AST matching.

Ah, I was figuring not wanting to diverge/provide toggles if we can help it - like unused warnings, opt-in features may go undertested (especially for these sort of operations being a bit subtle in some ways). Like we've discussed (at least I remember it coming up many years ago) trying to unify more of the static analyzer and IRGen to avoid divergence there - adding more divergence between static analysis and IRGen/etc seems liable to create more risk of bugs/inconsistencies.

[aaron.ballman]

clang/bindings/python/clang/cindex.py

1530

Well, I'm hoping we can find a way to avoid doing that in the general case while still giving users a way to opt into that behavior if they need it for the C APIs or AST matching.

Ah, I was figuring not wanting to diverge/provide toggles if we can help it - like unused warnings, opt-in features may go undertested (especially for these sort of operations being a bit subtle in some ways). Like we've discussed (at least I remember it coming up many years ago) trying to unify more of the static analyzer and IRGen to avoid divergence there - adding more divergence between static analysis and IRGen/etc seems liable to create more risk of bugs/inconsistencies.

I definitely see the appeal to not having a toggle. I was envisioning was more "generating an AST for matching over and C indexing API to create an AST will set this flag" rather than "user-facing way to decide on the behavior in arbitrary situations", but that does make testing more complicated because the C index code wouldn't be generating the same AST as a "normal" compilation.

Hmmm. This might be one of those times when we have to say "sorry, this is what the AST looks like and these APIs operate on the AST" without making changes. That would be pretty unfortunate because I think the use case from @anderslanglands is reasonable, but it also doesn't seem reasonable enough to warrant impacting the performance of all C++ compilations with Clang.

[dblaikie]

(pulling this out of inline comments because Phab's reply quoting doesn't work so well there & the threading/ordering gets weird too)

Well, I'm hoping we can find a way to avoid doing that in the general case while still giving users a way to opt into that behavior if they need it for the C APIs or AST matching.

Ah, I was figuring not wanting to diverge/provide toggles if we can help it - like unused warnings, opt-in features may go undertested (especially for these sort of operations being a bit subtle in some ways). Like we've discussed (at least I remember it coming up many years ago) trying to unify more of the static analyzer and IRGen to avoid divergence there - adding more divergence between static analysis and IRGen/etc seems liable to create more risk of bugs/inconsistencies.

I definitely see the appeal to not having a toggle. I was envisioning was more "generating an AST for matching over and C indexing API to create an AST will set this flag" rather than "user-facing way to decide on the behavior in arbitrary situations", but that does make testing more complicated because the C index code wouldn't be generating the same AST as a "normal" compilation.

*nod* Perhaps it's not the end of the world - just my thoughts/concerns. I won't feel too poorly if you go another way with this.

Hmmm. This might be one of those times when we have to say "sorry, this is what the AST looks like and these APIs operate on the AST" without making changes. That would be pretty unfortunate because I think the use case from @anderslanglands is reasonable, but it also doesn't seem reasonable enough to warrant impacting the performance of all C++ compilations with Clang.

I was hoping the rephrasing (is this really a question about which ctors the type has, or about how the type can be constructible) might offer us a way out for this use case, at least - if it's about how the type is constructible, then the AST wouldn't be the ideal/complete solution anyway and we could move more towards exposing the 5 special member ops as "can I do this thing/would this expression be valid".

[aaron.ballman]

In D135557#3871482, @dblaikie wrote:

I was hoping the rephrasing (is this really a question about which ctors the type has, or about how the type can be constructible) might offer us a way out for this use case, at least - if it's about how the type is constructible, then the AST wouldn't be the ideal/complete solution anyway and we could move more towards exposing the 5 special member ops as "can I do this thing/would this expression be valid".

FWIW, I'm about 99% sure there's no way to do that without use of Sema, which would require significant work to expose to the C indexing APIs and to AST matchers. At the AST level, we have "does this type have these methods" but it requires semantic analysis to determine whether something is copy constructible or not. e.g.,

struct S {
  S(S&) {}
};

This class has a usable copy constructor, yet it is not copy constructible per the type trait: https://godbolt.org/z/srefPjzxj

[dblaikie]

In D135557#3871622, @aaron.ballman wrote:

In D135557#3871482, @dblaikie wrote:

I was hoping the rephrasing (is this really a question about which ctors the type has, or about how the type can be constructible) might offer us a way out for this use case, at least - if it's about how the type is constructible, then the AST wouldn't be the ideal/complete solution anyway and we could move more towards exposing the 5 special member ops as "can I do this thing/would this expression be valid".

FWIW, I'm about 99% sure there's no way to do that without use of Sema, which would require significant work to expose to the C indexing APIs and to AST matchers.

Fair enough :/ not sure what to do about that.

At the AST level, we have "does this type have these methods" but it requires semantic analysis to determine whether something is copy constructible or not. e.g.,

struct S {
  S(S&) {}
};

This class has a usable copy constructor, yet it is not copy constructible per the type trait: https://godbolt.org/z/srefPjzxj

Ah, indeed, the inverse case - technically a copy ctor, but not one you can use in the ways you'd expect. Perhaps another question for @anderslanglands to consider.

(I'm still sort of curious how the AST matchers deal with all this - I guess they must have Sema available, because I'd assume they make all sorts of queries like "is this constructible from that" - since they're often trying to generate new code and want to know what constructs will be valid, which is different from the indexing use case, admittedly)

Maybe the answer is the C API isn't for this sort of thing/it's too nuanced to expose there?

But if you reckon the inconsistency isn't so bad, I won't be up in arms if you decide to go with having the indexing C API instantiate all the implicit special members all the time. I can see the value/it's only restricted to the indexing API. Does seem a bit unfortunate in tetrms of consistency.

[aaron.ballman]

In D135557#3871716, @dblaikie wrote:

(I'm still sort of curious how the AST matchers deal with all this - I guess they must have Sema available, because I'd assume they make all sorts of queries like "is this constructible from that" - since they're often trying to generate new code and want to know what constructs will be valid, which is different from the indexing use case, admittedly)

Nope, AST matchers don't have Sema available, so they don't have a way to query "is this constructible from that". You've got the AST itself (and the ASTContext) and not a whole lot else beyond that.

Maybe the answer is the C API isn't for this sort of thing/it's too nuanced to expose there?

But if you reckon the inconsistency isn't so bad, I won't be up in arms if you decide to go with having the indexing C API instantiate all the implicit special members all the time. I can see the value/it's only restricted to the indexing API. Does seem a bit unfortunate in tetrms of consistency.

Yeah, I think you convinced me that the consistency issue is something we should be wary of. I don't think we want to get into a situation where C index/AST matching is fundamentally a different AST than the rest of the compiler.

[dblaikie]

In D135557#3871803, @aaron.ballman wrote:

In D135557#3871716, @dblaikie wrote:

(I'm still sort of curious how the AST matchers deal with all this - I guess they must have Sema available, because I'd assume they make all sorts of queries like "is this constructible from that" - since they're often trying to generate new code and want to know what constructs will be valid, which is different from the indexing use case, admittedly)

Nope, AST matchers don't have Sema available, so they don't have a way to query "is this constructible from that". You've got the AST itself (and the ASTContext) and not a whole lot else beyond that.

Huh, that quite surprises me as to how some transformations are implemented in that situation. I guess maybe the more syntactically interesting ones are actual clang warnings with fixits, exposed via clang-tidy, so they have sema and all.

Maybe the answer is the C API isn't for this sort of thing/it's too nuanced to expose there?

But if you reckon the inconsistency isn't so bad, I won't be up in arms if you decide to go with having the indexing C API instantiate all the implicit special members all the time. I can see the value/it's only restricted to the indexing API. Does seem a bit unfortunate in tetrms of consistency.

Yeah, I think you convinced me that the consistency issue is something we should be wary of. I don't think we want to get into a situation where C index/AST matching is fundamentally a different AST than the rest of the compiler.

:/ sorry I don't have other great ideas to workaround these tradeoffs.

[royjacobson]

I would be more comfortable with exposing something like clang_CXXRecord_hasAnyNonDeletedDefaultConstructor. It's better than the confusing clang_CXXRecord_needsImplicitDefaultConstructor but it would still be different from the usual type traits in a subtle way. For the other special member functions that would be enough, we can use !CXXMethod::isIneligibleOrNotSelected() to know if their constraints are satisfied and there's no SFINAE problems because except for default constructors they're not allowed to be templates.

[aaron.ballman]

In D135557#3872324, @dblaikie wrote:

In D135557#3871803, @aaron.ballman wrote:

In D135557#3871716, @dblaikie wrote:

(I'm still sort of curious how the AST matchers deal with all this - I guess they must have Sema available, because I'd assume they make all sorts of queries like "is this constructible from that" - since they're often trying to generate new code and want to know what constructs will be valid, which is different from the indexing use case, admittedly)

Nope, AST matchers don't have Sema available, so they don't have a way to query "is this constructible from that". You've got the AST itself (and the ASTContext) and not a whole lot else beyond that.

Huh, that quite surprises me as to how some transformations are implemented in that situation. I guess maybe the more syntactically interesting ones are actual clang warnings with fixits, exposed via clang-tidy, so they have sema and all.

Yup! That's how clang-tidy can appear to have sema-related diagnostics.

In D135557#3872411, @royjacobson wrote:

I would be more comfortable with exposing something like clang_CXXRecord_hasAnyNonDeletedDefaultConstructor. It's better than the confusing clang_CXXRecord_needsImplicitDefaultConstructor but it would still be different from the usual type traits in a subtle way. For the other special member functions that would be enough, we can use !CXXMethod::isIneligibleOrNotSelected() to know if their constraints are satisfied and there's no SFINAE problems because except for default constructors they're not allowed to be templates.

I would be comfortable with such an API as that's no longer an implementation detail of our AST.

clang/bindings/python/clang/cindex.py

def is_virtual_method(self):
         return conf.lib.clang_CXXMethod_isVirtual(self)
 
     def is_abstract_record(self):
         """Returns True if the cursor refers to a C++ record declaration
         that has pure virtual member functions.
         """
         return conf.lib.clang_CXXRecord_isAbstract(self)
 
+    def record_defaulted_copy_constructor_is_deleted(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that has its default copy constructor deleted.
+        """
+        return conf.lib.clang_CXXRecord_defaultedCopyConstructorIsDeleted(self)
+
+    def record_defaulted_move_constructor_is_deleted(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that has its default move constructor deleted.
+        """
+        return conf.lib.clang_CXXRecord_defaultedMoveConstructorIsDeleted(self)
+
+    def record_defaulted_destructor_is_deleted(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that has its default destructor deleted.
+        """
+        return conf.lib.clang_CXXRecord_defaultedDestructorIsDeleted(self)
+
+    def record_needs_implicit_default_constructor(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that needs an implicit default constructor declared for it.
+        """
+        return conf.lib.clang_CXXRecord_needsImplicitDefaultConstructor(self)
+
+    def record_needs_implicit_copy_constructor(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that needs an implicit copy constructor declared for it.
+        """
+        return conf.lib.clang_CXXRecord_needsImplicitCopyConstructor(self)
+
+    def record_needs_implicit_copy_assignment(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that needs an implicit copy assignment declared for it.
+        """
+        return conf.lib.clang_CXXRecord_needsImplicitCopyAssignment(self)
+
+    def record_needs_implicit_move_constructor(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that needs an implicit move constructor declared for it.
+        """
+        return conf.lib.clang_CXXRecord_needsImplicitMoveConstructor(self)
+
+    def record_needs_implicit_move_assignment(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that needs an implicit move assignment declared for it.
+        """
+        return conf.lib.clang_CXXRecord_needsImplicitMoveAssignment(self)
+
+    def record_needs_implicit_destructor(self):
+        """Returns True if the cursor refers to a C++ record declaration
+        that needs an implicit destructor declared for it.
+        """
+        return conf.lib.clang_CXXRecord_needsImplicitDestructor(self)
+
     def is_scoped_enum(self):
         """Returns True if the cursor refers to a scoped enum declaration.
         """
         return conf.lib.clang_EnumDecl_isScoped(self)
 
     def get_definition(self):
         """
         If the cursor is a reference to a declaration or a declaration of

clang/include/clang-c/Index.h

 /*===-- clang-c/Index.h - Indexing Public C Interface -------------*- C -*-===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|

 
 /**
  * Determine if a C++ record is abstract, i.e. whether a class or struct
  * has a pure virtual member function.
  */
 CINDEX_LINKAGE unsigned clang_CXXRecord_isAbstract(CXCursor C);
 
 /**
+ * Returns true if a default copy constructor for this class or struct
+ * would be deleted.
+ * If this cursor does not refer to a class or struct, returns false.
+ */
+CINDEX_LINKAGE unsigned
+clang_CXXRecord_defaultedCopyConstructorIsDeleted(CXCursor C);
+
+/**
+ * Returns true if a default copy constructor for this class or struct
+ * would be deleted.
+ * If this cursor does not refer to a class or struct, returns false.
+ */
+CINDEX_LINKAGE unsigned
+clang_CXXRecord_defaultedMoveConstructorIsDeleted(CXCursor C);
+
+/**
+ * Returns true if a default destructor for this class or struct
+ * would be deleted.
+ * If this cursor does not refer to a class or struct, returns false.
+ */
+CINDEX_LINKAGE unsigned
+clang_CXXRecord_defaultedDestructorIsDeleted(CXCursor C);
+
+/**
+ * Returns true if the class requires a default constructor to be generated for
+ * it implicitly. If this cursor does not refer to a class or struct, returns
+ * false.
+ */
+CINDEX_LINKAGE unsigned
+clang_CXXRecord_needsImplicitDefaultConstructor(CXCursor C);
+
+/**
+ * Returns true if the class requires a copy constructor to be generated for it
+ * implicitly. If this cursor does not refer to a class or struct, returns
+ * false.
+ */
+CINDEX_LINKAGE unsigned clang_CXXRecord_needsImplicitCopyConstructor(CXCursor C);
+
+/**
+ * Returns true if the class requires a copy assignment operator to be generated
+ * for it implicitly. If this cursor does not refer to a class or struct,
+ * returns false.
+ */
+CINDEX_LINKAGE unsigned clang_CXXRecord_needsImplicitCopyAssignment(CXCursor C);
+
+/**
+ * Returns true if the class requires a move constructor to be generated for it
+ * implicitly. If this cursor does not refer to a class or struct, returns
+ * false.
+ */
+CINDEX_LINKAGE unsigned clang_CXXRecord_needsImplicitMoveConstructor(CXCursor C);
+
+/**
+ * Returns true if the class requires a move assignment operator to be generated
+ * for it implicitly. If this cursor does not refer to a class or struct,
+ * returns false.
+ */
+CINDEX_LINKAGE unsigned clang_CXXRecord_needsImplicitMoveAssignment(CXCursor C);
+
+/**
+ * Returns true if the class requires a destructor to be generated for it
+ * implicitly. If this cursor does not refer to a class or struct, returns
+ * false.
+ */
+CINDEX_LINKAGE unsigned clang_CXXRecord_needsImplicitDestructor(CXCursor C);
+
+/**
  * Determine if an enum declaration refers to a scoped enum.
  */
 CINDEX_LINKAGE unsigned clang_EnumDecl_isScoped(CXCursor C);
 
 /**
  * Determine if a C++ member function or member function template is
  * declared 'const'.
  */

clang/test/Index/annotate-attribute.cpp

 };
 
 template <typename T>
 class __attribute__((annotate("works"))) TemplateTest {};
 
 template <typename T>
 int templateFunction(T value) __attribute__((annotate("works")));
 
-// CHECK: ClassDecl=Test:3:7 (Definition) Extent=[3:1 - 17:2]
+// CHECK: ClassDecl=Test:3:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[3:1 - 17:2]
 // CHECK-NEXT: CXXAccessSpecifier=:4:1 (Definition) Extent=[4:1 - 4:8]
 // CHECK-NEXT: CXXMethod=aMethod:5:51 Extent=[5:3 - 5:60]
 // CHECK-NEXT: attribute(annotate)=spiffy_method Extent=[5:18 - 5:43]
 // CHECK-NEXT: CXXAccessSpecifier=:7:1 (Definition) Extent=[7:1 - 7:43]
 // CHECK-NEXT: attribute(annotate)=works Extent=[7:23 - 7:40]
 // CHECK-NEXT: CXXMethod=anotherMethod:8:8 Extent=[8:3 - 8:23]
 // CHECK-NEXT: attribute(annotate)=works Extent=[7:23 - 7:40]
 // CHECK-NEXT: CXXAccessSpecifier=:10:1 (Definition) Extent=[10:1 - 10:53]

clang/test/Index/availability.cpp

 void foo() = delete;
 
 struct Foo {
   int foo() = delete;
   Foo() = delete;
 };
 
 
 // RUN: c-index-test -test-print-type --std=c++11 %s | FileCheck %s
 // CHECK: FunctionDecl=foo:1:6 (unavailable) [type=void ()] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [isPOD=0]
-// CHECK: StructDecl=Foo:3:8 (Definition) [type=Foo] [typekind=Record] [isPOD=1]
+// CHECK: StructDecl=Foo:3:8 (Definition) (needs cassign) (needs massign) (needs dtor) [type=Foo] [typekind=Record] [isPOD=1]
 // CHECK: CXXMethod=foo:4:7 (unavailable) (deleted) [type=int (){{.*}}] [typekind=FunctionProto] [resulttype=int] [resulttypekind=Int] [isPOD=0]
 // CHECK: CXXConstructor=Foo:5:3 (unavailable) (default constructor) (deleted) [type=void (){{.*}}] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [isPOD=0]

clang/test/Index/deletion.cpp

 struct Foo {
   int foo() = delete;
   int bar();
   Foo() = delete;
   Foo(int);
 };
 
 
 // RUN: c-index-test -test-print-type --std=c++11 %s | FileCheck %s
-// CHECK: StructDecl=Foo:1:8 (Definition) [type=Foo] [typekind=Record] [isPOD=1]
+// CHECK: StructDecl=Foo:1:8 (Definition) (needs cassign) (needs massign) (needs dtor) [type=Foo] [typekind=Record] [isPOD=1]
 // CHECK: CXXMethod=foo:2:7 (unavailable) (deleted) [type=int (){{.*}}] [typekind=FunctionProto] [resulttype=int] [resulttypekind=Int] [isPOD=0]
 // CHECK: CXXMethod=bar:3:7 [type=int (){{.*}}] [typekind=FunctionProto] [resulttype=int] [resulttypekind=Int] [isPOD=0]
 // CHECK: CXXConstructor=Foo:4:3 (unavailable) (default constructor) (deleted) [type=void (){{.*}}] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [isPOD=0]
 // CHECK: CXXConstructor=Foo:5:3 (converting constructor) [type=void (int){{.*}}] [typekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [int] [Int]] [isPOD=0]

clang/test/Index/file-refs.cpp

 // CHECK-NEXT: Namespace=NS:1:11 (Definition) =[1:11 - 1:13]
 // CHECK-NEXT: NamespaceRef=NS:1:11 =[9:6 - 9:8]
 // CHECK-NEXT: NamespaceRef=NS:1:11 =[15:3 - 15:5]
 // CHECK-NEXT: NamespaceRef=NS:1:11 =[16:3 - 16:5]
 // CHECK-NEXT: NamespaceRef=NS:1:11 =[16:14 - 16:16]
 
 // RUN:  -file-refs-at=%s:2:9 \
 // CHECK-NEXT: ClassDecl=C:2:9 (Definition)
-// CHECK-NEXT: ClassDecl=C:2:9 (Definition) =[2:9 - 2:10]
+// CHECK-NEXT: ClassDecl=C:2:9 (Definition) (needs cassign) (needs massign) =[2:9 - 2:10]
 // CHECK-NEXT: CXXConstructor=C:4:5 (Definition) (default constructor) =[4:5 - 4:6]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[9:10 - 9:11]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[10:3 - 10:4]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[15:7 - 15:8]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[16:7 - 16:8]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[16:18 - 16:19]
 
 // RUN:  -file-refs-at=%s:16:18 \
 // CHECK-NEXT: CallExpr=C:4:5
-// CHECK-NEXT: ClassDecl=C:2:9 (Definition) =[2:9 - 2:10]
+// CHECK-NEXT: ClassDecl=C:2:9 (Definition) (needs cassign) (needs massign) =[2:9 - 2:10]
 // CHECK-NEXT: CXXConstructor=C:4:5 (Definition) (default constructor) =[4:5 - 4:6]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[9:10 - 9:11]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[10:3 - 10:4]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[15:7 - 15:8]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[16:7 - 16:8]
 // CHECK-NEXT: TypeRef=class NS::C:2:9 =[16:18 - 16:19]
 
 // RUN:  -file-refs-at=%s:20:8 \

clang/test/Index/get-cursor.cpp

 // RUN: c-index-test -cursor-at=%s:45:9 %s | FileCheck -check-prefix=CHECK-LOCALCLASS %s
 // CHECK-LOCALCLASS: 45:9 DeclRefExpr=x:44:11 Extent=[45:9 - 45:10] Spelling=x ([45:9 - 45:10])
 
 // RUN: c-index-test -cursor-at=%s:50:23 -cursor-at=%s:55:23 %s | FileCheck -check-prefix=CHECK-TEMPLPARAM %s
 // CHECK-TEMPLPARAM: 50:23 TypeRef=struct X:3:8 Extent=[50:23 - 50:24] Spelling=struct X ([50:23 - 50:24])
 // CHECK-TEMPLPARAM: 55:23 TypeRef=struct X:3:8 Extent=[55:23 - 55:24] Spelling=struct X ([55:23 - 55:24])
 
 // RUN: c-index-test -cursor-at=%s:66:23 %s | FileCheck -check-prefix=CHECK-TEMPLSPEC %s
-// CHECK-TEMPLSPEC: 66:23 ClassDecl=TC:66:23 (Definition) [Specialization of TC:59:7] [Template arg 0: kind: 1, type: char] Extent=[66:1 - 66:31] Spelling=TC ([66:23 - 66:25])
+// CHECK-TEMPLSPEC: 66:23 ClassDecl=TC:66:23 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [Specialization of TC:59:7] [Template arg 0: kind: 1, type: char] Extent=[66:1 - 66:31] Spelling=TC ([66:23 - 66:25])
 
 // RUN: c-index-test -cursor-at=%s:69:3 -cursor-at=%s:70:11 -cursor-at=%s:73:6 -cursor-at=%s:74:6 -cursor-at=%s:77:8 -cursor-at=%s:78:8 -cursor-at=%s:79:8 -cursor-at=%s:80:8 -cursor-at=%s:81:8 -cursor-at=%s:82:8 -cursor-at=%s:85:6 -cursor-at=%s:86:6 -cursor-at=%s:87:6 -cursor-at=%s:88:6 -cursor-at=%s:91:5 -cursor-at=%s:92:5 -cursor-at=%s:93:5 -cursor-at=%s:94:5 -cursor-at=%s:95:5 -cursor-at=%s:96:5 -cursor-at=%s:97:5 -cursor-at=%s:98:5 -cursor-at=%s:100:5 -cursor-at=%s:101:5 -cursor-at=%s:104:6 -cursor-at=%s:105:6 -cursor-at=%s:106:6 -cursor-at=%s:107:6 -cursor-at=%s:108:6 -cursor-at=%s:109:6 -cursor-at=%s:110:6 -cursor-at=%s:111:6 -cursor-at=%s:113:6 -cursor-at=%s:114:6 -cursor-at=%s:117:8 -cursor-at=%s:118:8 -cursor-at=%s:120:8 -cursor-at=%s:121:8 -cursor-at=%s:122:8 -cursor-at=%s:123:8 -cursor-at=%s:124:8 -cursor-at=%s:125:8 -cursor-at=%s:128:6 -cursor-at=%s:129:6 -cursor-at=%s:130:6 -cursor-at=%s:132:3 -cursor-at=%s:146:15 -cursor-at=%s:149:6 -cursor-at=%s:150:25 -cursor-at=%s:151:6 -cursor-at=%s:152:6 -cursor-at=%s:153:6 -cursor-at=%s:154:6 -cursor-at=%s:155:6 -std=c++11 %s | FileCheck -check-prefix=CHECK-SPELLING %s
 // CHECK-SPELLING: 69:3 CXXConstructor=A:69:3 (default constructor) Extent=[69:3 - 69:6] Spelling=A ([69:3 - 69:4])
 // CHECK-SPELLING: 70:11 CXXDestructor=~A:70:11 (virtual) Extent=[70:3 - 70:15] Spelling=~A ([70:11 - 70:13])
 // CHECK-SPELLING: 73:6 CXXMethod=operator=:73:6 Extent=[73:3 - 73:25] Spelling=operator= ([73:6 - 73:15])
 // CHECK-SPELLING: 74:6 CXXMethod=operator=:74:6 (noexcept) Extent=[74:3 - 74:29] Spelling=operator= ([74:6 - 74:15])
 // CHECK-SPELLING: 77:8 CXXMethod=operator+:77:8 (const) Extent=[77:3 - 77:25] Spelling=operator+ ([77:8 - 77:17])
 // CHECK-SPELLING: 78:8 CXXMethod=operator-:78:8 (const) Extent=[78:3 - 78:25] Spelling=operator- ([78:8 - 78:17])

clang/test/Index/index-templates.cpp

 // CHECK-LOAD: index-templates.cpp:4:13: DeclRefExpr=Value:3:24 Extent=[4:13 - 4:18]
 // CHECK-LOAD: index-templates.cpp:6:28: ClassTemplate=allocator:6:28 Extent=[6:1 - 6:37]
 // CHECK-LOAD: index-templates.cpp:6:19: TemplateTypeParameter=T:6:19 (Definition) Extent=[6:10 - 6:20]
 // CHECK-LOAD: index-templates.cpp:9:7: ClassTemplate=vector:9:7 (Definition) Extent=[8:1 - 11:2]
 // CHECK-LOAD: index-templates.cpp:8:19: TemplateTypeParameter=T:8:19 (Definition) Extent=[8:10 - 8:20]
 // CHECK-LOAD: index-templates.cpp:8:31: TemplateTypeParameter=Alloc:8:31 (Definition) Extent=[8:22 - 8:51]
 // CHECK-LOAD: index-templates.cpp:8:39: TemplateRef=allocator:6:28 Extent=[8:39 - 8:48]
 // CHECK-LOAD: index-templates.cpp:10:8: CXXMethod=clear:10:8 Extent=[10:3 - 10:15]
-// CHECK-LOAD: index-templates.cpp:14:7: ClassTemplatePartialSpecialization=vector:14:7 (Definition) [Specialization of vector:9:7] [Template arg 0: kind: 1, type: type-parameter-0-0 *] [Template arg 1: kind: 1, type: allocator<type-parameter-0-0 *>] Extent=[13:1 - 14:21]
+// CHECK-LOAD: index-templates.cpp:14:7: ClassTemplatePartialSpecialization=vector:14:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [Specialization of vector:9:7] [Template arg 0: kind: 1, type: type-parameter-0-0 *] [Template arg 1: kind: 1, type: allocator<type-parameter-0-0 *>] Extent=[13:1 - 14:21]
 // CHECK-LOAD: index-templates.cpp:13:19: TemplateTypeParameter=T:13:19 (Definition) Extent=[13:10 - 13:20]
-// CHECK-LOAD: index-templates.cpp:16:8: StructDecl=Z1:16:8 (Definition) Extent=[16:1 - 16:14]
-// CHECK-LOAD: index-templates.cpp:18:16: ClassDecl=vector:18:16 (Definition) [Specialization of vector:9:7] [Template arg 0: kind: 1, type: Z1] [Template arg 1: kind: 1, type: allocator<Z1>] Extent=[18:1 - 18:26]
+// CHECK-LOAD: index-templates.cpp:16:8: StructDecl=Z1:16:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[16:1 - 16:14]
+// CHECK-LOAD: index-templates.cpp:18:16: ClassDecl=vector:18:16 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [Specialization of vector:9:7] [Template arg 0: kind: 1, type: Z1] [Template arg 1: kind: 1, type: allocator<Z1>] Extent=[18:1 - 18:26]
 // CHECK-LOAD: index-templates.cpp:18:23: TypeRef=struct Z1:16:8 Extent=[18:23 - 18:25]
 // CHECK-LOAD-NOT: CXXMethod=clear
-// CHECK-LOAD: index-templates.cpp:20:8: StructDecl=Z2:20:8 (Definition) Extent=[20:1 - 20:14]
-// CHECK-LOAD: index-templates.cpp:23:7: ClassDecl=vector:23:7 (Definition) [Specialization of vector:9:7] [Template arg 0: kind: 1, type: Z2] [Template arg 1: kind: 1, type: allocator<Z2>] Extent=[22:1 - 25:2]
+// CHECK-LOAD: index-templates.cpp:20:8: StructDecl=Z2:20:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[20:1 - 20:14]
+// CHECK-LOAD: index-templates.cpp:23:7: ClassDecl=vector:23:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [Specialization of vector:9:7] [Template arg 0: kind: 1, type: Z2] [Template arg 1: kind: 1, type: allocator<Z2>] Extent=[22:1 - 25:2]
 // CHECK-LOAD: index-templates.cpp:23:14: TypeRef=struct Z2:20:8 Extent=[23:14 - 23:16]
 // CHECK-LOAD: index-templates.cpp:24:8: CXXMethod=clear:24:8 Extent=[24:3 - 24:15]
 // CHECK-LOAD: index-templates.cpp:28:8: ClassTemplate=Y:28:8 (Definition) Extent=[27:1 - 31:2]
 // CHECK-LOAD: index-templates.cpp:27:19: TemplateTypeParameter=T:27:19 (Definition) Extent=[27:10 - 27:20]
 // CHECK-LOAD: index-templates.cpp:27:31: TemplateTypeParameter=U:27:31 (Definition) Extent=[27:22 - 27:32]
 // CHECK-LOAD: index-templates.cpp:29:21: UsingDeclaration=type:29:21 Extent=[29:3 - 29:25]
 // CHECK-LOAD: index-templates.cpp:30:12: UsingDeclaration=operator Z2:30:12 Extent=[30:3 - 30:23]
 // CHECK-LOAD: index-templates.cpp:30:21: TypeRef=struct Z2:20:8 Extent=[30:21 - 30:23]

 // CHECK-LOAD: index-templates.cpp:39:27: TemplateTypeParameter=:39:27 (Definition) Extent=[39:19 - 39:27]
 // CHECK-LOAD: index-templates.cpp:39:37: NonTypeTemplateParameter=:39:37 (Definition) Extent=[39:29 - 39:37]
 // CHECK-LOAD: index-templates.cpp:39:61: TemplateRef=array:37:8 Extent=[39:61 - 39:66]
 // CHECK-LOAD: index-templates.cpp:42:18: TypedefDecl=Unsigned:42:18 (Definition) Extent=[42:1 - 42:26]
 // CHECK-LOAD: index-templates.cpp:45:8: ClassTemplate=value_c:45:8 Extent=[44:1 - 45:15]
 // CHECK-LOAD: index-templates.cpp:44:19: TemplateTypeParameter=T:44:19 (Definition) Extent=[44:10 - 44:20]
 // CHECK-LOAD: index-templates.cpp:44:31: NonTypeTemplateParameter=Value:44:31 (Definition) Extent=[44:22 - 44:36]
 // CHECK-LOAD: index-templates.cpp:44:22: TypeRef=Unsigned:42:18 Extent=[44:22 - 44:30]
-// CHECK-LOAD: index-templates.cpp:47:16: ClassDecl=vector:47:16 (Definition) [Specialization of vector:14:7] [Template arg 0: kind: 1, type: int *] [Template arg 1: kind: 1, type: allocator<int *>] Extent=[47:1 - 47:28]
-// CHECK-LOAD: index-templates.cpp:49:8: StructDecl=Z4:49:8 (Definition) Extent=[49:1 - 51:2]
+// CHECK-LOAD: index-templates.cpp:47:16: ClassDecl=vector:47:16 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [Specialization of vector:14:7] [Template arg 0: kind: 1, type: int *] [Template arg 1: kind: 1, type: allocator<int *>] Extent=[47:1 - 47:28]
+// CHECK-LOAD: index-templates.cpp:49:8: StructDecl=Z4:49:8 (Definition) (needs cassign) (needs massign) Extent=[49:1 - 51:2]
 // CHECK-LOAD: index-templates.cpp:50:26: FunctionTemplate=getAs:50:26 Extent=[50:3 - 50:33]
 // CHECK-LOAD: index-templates.cpp:50:21: TemplateTypeParameter=T:50:21 (Definition) Extent=[50:12 - 50:22]
 // CHECK-LOAD: index-templates.cpp:53:6: FunctionDecl=template_exprs:53:6 (Definition)
 // CHECK-LOAD: index-templates.cpp:54:3: CallExpr=f:4:6 Extent=[54:3 - 54:68]
 // CHECK-LOAD: index-templates.cpp:54:3: UnexposedExpr=f:4:6 Extent=[54:3 - 54:35]
 // CHECK-LOAD: index-templates.cpp:54:3: DeclRefExpr=f:4:6 RefName=[54:3 - 54:4] RefName=[54:4 - 54:35] Extent=[54:3 - 54:35]
 // CHECK-LOAD: index-templates.cpp:54:5: TypeRef=Unsigned:42:18 Extent=[54:5 - 54:13]
 // CHECK-LOAD: index-templates.cpp:54:15: DeclRefExpr=OneDimension:35:16 Extent=[54:15 - 54:27]
 // CHECK-LOAD: index-templates.cpp:54:29: TemplateRef=value:52:32 Extent=[54:29 - 54:34]
 // CHECK-LOAD: index-templates.cpp:55:8: MemberRefExpr=getAs:50:26 SingleRefName=[55:8 - 55:13] RefName=[55:8 - 55:13] Extent=[55:3 - 55:23]
 // CHECK-LOAD: index-templates.cpp:55:3: CallExpr=Z4:49:8 Extent=[55:3 - 55:7]
 // CHECK-LOAD: index-templates.cpp:55:14: TypeRef=Unsigned:42:18 Extent=[55:14 - 55:22]
 // CHECK-LOAD: index-templates.cpp:68:6: FunctionTemplate=unresolved_exprs:68:6 (Definition)
 // CHECK-LOAD: index-templates.cpp:69:3: OverloadedDeclRef=swap[60:6, 59:39, 58:27]
 // CHECK-LOAD: index-templates.cpp:71:6: OverloadedDeclRef=f[63:7, 64:9]
 // CHECK-LOAD: index-templates.cpp:72:3: OverloadedDeclRef=swap[58:27, 59:39]
 // CHECK-LOAD: index-templates.cpp:82:6: FunctionTemplate=init_list:82:6 (Definition)
 // CHECK-LOAD: index-templates.cpp:85:14: VarDecl=p:85:14 (Definition)
 // CHECK-LOAD: index-templates.cpp:85:20: DeclRefExpr=t:82:18 Extent=[85:20 - 85:21]
 // CHECK-LOAD: index-templates.cpp:85:23: TypeRef=second_type:83:13 Extent=[85:23 - 85:34]
 // CHECK-LOAD: index-templates.cpp:85:35: DeclRefExpr=u:82:23 Extent=[85:35 - 85:36]
-// CHECK-LOAD: index-templates.cpp:98:16: StructDecl=Pair:98:16 (Definition) [Specialization of Pair:76:8] [Template arg 0: kind: 1, type: int] [Template arg 1: kind: 1, type: int] Extent=[98:1 - 98:30]
+// CHECK-LOAD: index-templates.cpp:98:16: StructDecl=Pair:98:16 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor)  [Specialization of Pair:76:8] [Template arg 0: kind: 1, type: int] [Template arg 1: kind: 1, type: int] Extent=[98:1 - 98:30]
 // CHECK-LOAD: index-templates.cpp:101:8: ClassTemplate=SuperPair:101:8 (Definition) Extent=[100:1 - 101:50]
 // CHECK-LOAD: index-templates.cpp:100:19: TemplateTypeParameter=T:100:19 (Definition) Extent=[100:10 - 100:20]
 // CHECK-LOAD: index-templates.cpp:100:31: TemplateTypeParameter=U:100:31 (Definition) Extent=[100:22 - 100:32]
 // CHECK-LOAD: index-templates.cpp:101:20: C++ base class specifier=Pair<int, int>:98:16 [access=public isVirtual=false] Extent=[101:20 - 101:34]
 // CHECK-LOAD: index-templates.cpp:101:36: C++ base class specifier=Pair<T, U>:76:8 [access=public isVirtual=false] Extent=[101:36 - 101:46]
 // CHECK-LOAD: index-templates.cpp:111:6: FunctionDecl=foo:111:6 [Specialization of foo:107:6] [Template arg 0: kind: 1, type: float] [Template arg 1: kind: 4, intval: 9] [Template arg 2: kind: 4, intval: 1] [Template arg 3: kind: 4, intval: 14] Extent=[110:1 - 111:64]
 // CHECK-LOAD: index-templates.cpp:114:1: TypeAliasTemplateDecl=alias:114:1 (Definition) Extent=[113:1 - 114:16]
 // CHECK-LOAD: index-templates.cpp:113:17: TemplateTypeParameter=T:113:17 (Definition) Extent=[113:11 - 113:18] [access=public]

clang/test/Index/keep-going.cpp

 
 // CHECK: inclusion directive=missing1.h ((null)) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: inclusion directive=missing2.h ((null)) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: inclusion directive=foo.h ({{.*[/\\]}}test{{[/\\]}}Index{{[/\\]}}Inputs{{[/\\]}}foo.h) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: ClassTemplate=A:4:7 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:3:16 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: FieldDecl=a:4:13 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: TypeRef=T:3:16 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
-// CHECK: ClassDecl=B:6:7 (Definition) [type=B] [typekind=Record] [isPOD=0]
+// CHECK: ClassDecl=B:6:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=B] [typekind=Record] [isPOD=0]
 // CHECK: C++ base class specifier=A<int>:4:7 [access=public isVirtual=false] [type=A<int>] [typekind=Elaborated] [templateargs/1= [type=int] [typekind=Int]] [canonicaltype=A<int>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=int] [typekind=Int]] [isPOD=0] [nbFields=1]
 // CHECK: TemplateRef=A:4:7 [type=] [typekind=Invalid] [isPOD=0]
-// CHECK: ClassDecl=C:10:7 (Definition) [type=C] [typekind=Record] [isPOD=0]
+// CHECK: ClassDecl=C:10:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=C] [typekind=Record] [isPOD=0]
 // CHECK: C++ base class specifier=A<float>:4:7 [access=public isVirtual=false] [type=A<float>] [typekind=Elaborated] [templateargs/1= [type=float] [typekind=Float]] [canonicaltype=A<float>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=float] [typekind=Float]] [isPOD=0] [nbFields=1]
 // CHECK: TemplateRef=A:4:7 [type=] [typekind=Invalid] [isPOD=0]
 
 // CHECK-KEEP-GOING-ONLY: VarDecl=global_var:1:12 [type=int] [typekind=Int] [isPOD=1]
 
 // CHECK-DIAG: keep-going.cpp:1:10: error: 'missing1.h' file not found
 // CHECK-DIAG: keep-going.cpp:8:10: error: 'missing2.h' file not found

clang/test/Index/load-stmts.cpp

 }
 
 void casts(int *ip) {
   (void)reinterpret_cast<float *>(ip);
 }
 
 // RUN: c-index-test -test-load-source all -fno-delayed-template-parsing -frtti %s | FileCheck %s
 // CHECK: load-stmts.cpp:1:13: TypedefDecl=T:1:13 (Definition) Extent=[1:1 - 1:14]
-// CHECK: load-stmts.cpp:2:8: StructDecl=X:2:8 (Definition) Extent=[2:1 - 2:23]
+// CHECK: load-stmts.cpp:2:8: StructDecl=X:2:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[2:1 - 2:23]
 // CHECK: load-stmts.cpp:2:16: FieldDecl=a:2:16 (Definition) Extent=[2:12 - 2:17]
 // CHECK: load-stmts.cpp:2:19: FieldDecl=b:2:19 (Definition) Extent=[2:12 - 2:20]
 // CHECK: load-stmts.cpp:3:6: FunctionDecl=f:3:6 (Definition) Extent=[3:1 - 11:2]
 // CHECK: load-stmts.cpp:3:12: ParmDecl=x:3:12 (Definition) Extent=[3:8 - 3:13]
 // CHECK: load-stmts.cpp:4:10: VarDecl=y:4:10 (Definition) Extent=[4:8 - 4:15]
 // CHECK: load-stmts.cpp:4:8: TypeRef=T:1:13 Extent=[4:8 - 4:9]
 // CHECK: load-stmts.cpp:4:14: DeclRefExpr=x:3:12 Extent=[4:14 - 4:15]
 // CHECK: load-stmts.cpp:4:19: VarDecl=z:4:19 (Definition) Extent=[4:17 - 4:24]

 // CHECK: load-stmts.cpp:7:19: DeclRefExpr=x:3:12 Extent=[7:19 - 7:20]
 // CHECK: load-stmts.cpp:7:13: UnexposedExpr=z3:7:13 Extent=[7:13 - 7:15]
 // CHECK: load-stmts.cpp:7:13: DeclRefExpr=z3:7:13 Extent=[7:13 - 7:15]
 // CHECK: load-stmts.cpp:8:13: VarDecl=z4:8:13 (Definition) Extent=[8:11 - 8:19]
 // CHECK: load-stmts.cpp:8:11: TypeRef=T:1:13 Extent=[8:11 - 8:12]
 // CHECK: load-stmts.cpp:8:18: DeclRefExpr=x:3:12 Extent=[8:18 - 8:19]
 // CHECK: load-stmts.cpp:8:13: DeclRefExpr=z4:8:13 Extent=[8:13 - 8:15]
 // CHECK: load-stmts.cpp:9:8: IntegerLiteral= Extent=[9:8 - 9:10]
-// CHECK: load-stmts.cpp:14:7: ClassDecl=A:14:7 (Definition) Extent=[14:1 - 16:2]
+// CHECK: load-stmts.cpp:14:7: ClassDecl=A:14:7 (Definition) (needs ctor) (needs cctor) (needs mctor) Extent=[14:1 - 16:2]
 // CHECK: load-stmts.cpp:15:8: CXXMethod=doA:15:8 Extent=[15:3 - 15:13]
-// CHECK: load-stmts.cpp:18:7: ClassDecl=B:18:7 (Definition) Extent=[18:1 - 20:2]
+// CHECK: load-stmts.cpp:18:7: ClassDecl=B:18:7 (Definition) (needs ctor) (needs cctor) (needs mctor) Extent=[18:1 - 20:2]
 // CHECK: load-stmts.cpp:19:8: CXXMethod=doB:19:8 Extent=[19:3 - 19:13]
-// CHECK: load-stmts.cpp:22:7: ClassDecl=C:22:7 (Definition) Extent=[22:1 - 24:2]
+// CHECK: load-stmts.cpp:22:7: ClassDecl=C:22:7 (Definition) (needs ctor) (needs cctor) (needs mctor) Extent=[22:1 - 24:2]
 // CHECK: load-stmts.cpp:22:18: C++ base class specifier=A:14:7 [access=public isVirtual=false]
 // CHECK: load-stmts.cpp:22:29: C++ base class specifier=B:18:7 [access=private isVirtual=false]
 // CHECK: load-stmts.cpp:23:8: CXXMethod=doC:23:8 Extent=[23:3 - 23:13]
-// CHECK: load-stmts.cpp:26:7: ClassDecl=D:26:7 (Definition) Extent=[26:1 - 26:49]
+// CHECK: load-stmts.cpp:26:7: ClassDecl=D:26:7 (Definition) (needs ctor) (needs cctor) (needs mctor) Extent=[26:1 - 26:49]
 // CHECK: load-stmts.cpp:26:26: C++ base class specifier=C:22:7 [access=public isVirtual=true]
 // CHECK: load-stmts.cpp:26:45: C++ base class specifier=A:14:7 [access=private isVirtual=true]
 // CHECK: load-stmts.cpp:33:7: VarDecl=typeid_marker:33:7 (Definition)
 // CHECK: load-stmts.cpp:34:10: TypeRef=class C:22:7 Extent=[34:10 - 34:11]
 // CHECK: load-stmts.cpp:35:10: DeclRefExpr=c:32:20 Extent=[35:10 - 35:11]
 // CHECK: load-stmts.cpp:37:12: VarDecl=int_ptr:37:12 (Definition) Extent=[37:3 - 37:19]
 // CHECK: load-stmts.cpp:37:3: TypeRef=Integer:36:15 Extent=[37:3 - 37:10]
 // CHECK: load-stmts.cpp:38:3: DeclRefExpr=int_ptr:37:12 Extent=[38:3 - 38:10]

clang/test/Index/print-display-names.cpp

 // DISPLAY_NAME: print-display-names.cpp:6:16: ClassDecl=ClassTmpl<Integer, Integer>:6:16 (Definition)
 // DISPLAY_NAME: print-display-names.cpp:8:6: FunctionDecl=f(ClassTmpl<float, Integer>):8:6
 // DISPLAY_NAME: print-display-names.cpp:11:6: FunctionTemplate=g(ClassTmpl<T, T>):11:6
 // DISPLAY_NAME: print-display-names.cpp:13:17: FunctionDecl=g<>(ClassTmpl<int, int>):13:17 [Specialization of g:11:6]
 
 // RUN: env CINDEXTEST_PRINTINGPOLICY_TERSEOUTPUT=1 c-index-test -test-load-source all-pretty %s | FileCheck %s --check-prefix=PRETTY
 // PRETTY: print-display-names.cpp:2:7: ClassTemplate=template <typename T, typename> class ClassTmpl {}:2:7 (Definition) Extent=[1:1 - 2:20]
 // PRETTY: print-display-names.cpp:4:13: TypedefDecl=typedef int Integer:4:13 (Definition) Extent=[4:1 - 4:20]
-// PRETTY: print-display-names.cpp:6:16: ClassDecl=template<> class ClassTmpl<Integer, Integer> {}:6:16 (Definition) [Specialization of ClassTmpl:2:7] [Template arg 0: kind: 1, type: int] [Template arg 1: kind: 1, type: int] Extent=[6:1 - 6:43]
+// PRETTY: print-display-names.cpp:6:16: ClassDecl=template<> class ClassTmpl<Integer, Integer> {}:6:16 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [Specialization of ClassTmpl:2:7] [Template arg 0: kind: 1, type: int] [Template arg 1: kind: 1, type: int] Extent=[6:1 - 6:43]
 // PRETTY: print-display-names.cpp:8:6: FunctionDecl=void f(ClassTmpl<float, Integer> p):8:6 Extent=[8:1 - 8:36]
 // PRETTY: print-display-names.cpp:8:34: ParmDecl=ClassTmpl<float, Integer> p:8:34 (Definition) Extent=[8:8 - 8:35]
 // PRETTY: print-display-names.cpp:11:6: FunctionTemplate=template <typename T> void g(ClassTmpl<T, T>):11:6 Extent=[10:1 - 11:24]
 // PRETTY: print-display-names.cpp:11:23: ParmDecl=ClassTmpl<T, T>:11:23 (Definition) Extent=[11:8 - 11:23]
 // PRETTY: print-display-names.cpp:13:17: FunctionDecl=template<> void g<int>(ClassTmpl<int, int>):13:17 [Specialization of g:11:6] [Template arg 0: kind: 1, type: int] Extent=[13:1 - 13:44]
 // PRETTY: print-display-names.cpp:13:43: ParmDecl=ClassTmpl<int, int>:13:43 (Definition) Extent=[13:24 - 13:43]

clang/test/Index/print-type-size.cpp

 // from SemaCXX/class-layout.cpp
 // RUN: c-index-test -test-print-type-size %s -target x86_64-pc-linux-gnu | FileCheck -check-prefix=CHECK64 %s
 // RUN: c-index-test -test-print-type-size %s -target i386-apple-darwin9 | FileCheck -check-prefix=CHECK32 %s
 
 namespace basic {
 
 // CHECK64: VarDecl=v:[[@LINE+2]]:6 (Definition) (invalid) [type=void] [typekind=Void]
 // CHECK32: VarDecl=v:[[@LINE+1]]:6 (Definition) (invalid) [type=void] [typekind=Void]
 void v;
 
 // CHECK64: VarDecl=v1:[[@LINE+2]]:7 (Definition) [type=void *] [typekind=Pointer] [sizeof=8] [alignof=8]
 // CHECK32: VarDecl=v1:[[@LINE+1]]:7 (Definition) [type=void *] [typekind=Pointer] [sizeof=4] [alignof=4]
 void *v1;
 
 // offsetof
-// CHECK64: StructDecl=simple:[[@LINE+2]]:8 (Definition) [type=basic::simple] [typekind=Record] [sizeof=48] [alignof=8]
-// CHECK32: StructDecl=simple:[[@LINE+1]]:8 (Definition) [type=basic::simple] [typekind=Record] [sizeof=36] [alignof=4]
+// CHECK64: StructDecl=simple:[[@LINE+2]]:8 (Definition) (needs cassign) (needs massign) (needs dtor) [type=basic::simple] [typekind=Record] [sizeof=48] [alignof=8]
+// CHECK32: StructDecl=simple:[[@LINE+1]]:8 (Definition) (needs cassign) (needs massign) (needs dtor) [type=basic::simple] [typekind=Record] [sizeof=36] [alignof=4]
 struct simple {
   int a;
   char b;
 // CHECK64: FieldDecl=c:[[@LINE+1]]:7 (Definition) [type=int] [typekind=Int] [sizeof=4] [alignof=4] [offsetof=40] [BitFieldSize=3]
   int c:3;
   long d;
   int e:5;
 // CHECK64: FieldDecl=f:[[@LINE+1]]:7 (Definition) [type=int] [typekind=Int] [sizeof=4] [alignof=4] [offsetof=133] [BitFieldSize=4]
class B {
   A* a1;
   A& a2;
 };
 
 }
 
 namespace Sizes {
 
-// CHECK64: StructDecl=A:[[@LINE+2]]:8 (Definition) [type=Sizes::A] [typekind=Record] [sizeof=8] [alignof=4]
-// CHECK32: StructDecl=A:[[@LINE+1]]:8 (Definition) [type=Sizes::A] [typekind=Record] [sizeof=8] [alignof=4]
+// CHECK64: StructDecl=A:[[@LINE+2]]:8 (Definition) (needs cassign) (needs massign) [type=Sizes::A] [typekind=Record] [sizeof=8] [alignof=4]
+// CHECK32: StructDecl=A:[[@LINE+1]]:8 (Definition) (needs cassign) (needs massign) [type=Sizes::A] [typekind=Record] [sizeof=8] [alignof=4]
 struct A {
   int a;
   char b;
 };
 
-// CHECK64: StructDecl=B:[[@LINE+2]]:8 (Definition) [type=Sizes::B] [typekind=Record] [sizeof=12] [alignof=4]
-// CHECK32: StructDecl=B:[[@LINE+1]]:8 (Definition) [type=Sizes::B] [typekind=Record] [sizeof=12] [alignof=4]
+// CHECK64: StructDecl=B:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::B] [typekind=Record] [sizeof=12] [alignof=4]
+// CHECK32: StructDecl=B:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::B] [typekind=Record] [sizeof=12] [alignof=4]
 struct B : A {
   char c;
 };
 
-// CHECK64: StructDecl=C:[[@LINE+2]]:8 (Definition) [type=Sizes::C] [typekind=Record] [sizeof=8] [alignof=4]
-// CHECK32: StructDecl=C:[[@LINE+1]]:8 (Definition) [type=Sizes::C] [typekind=Record] [sizeof=8] [alignof=4]
+// CHECK64: StructDecl=C:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::C] [typekind=Record] [sizeof=8] [alignof=4]
+// CHECK32: StructDecl=C:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::C] [typekind=Record] [sizeof=8] [alignof=4]
 struct C {
 // Make fields private so C won't be a POD type.
 private:
   int a;
   char b;
 };
 
-// CHECK64: StructDecl=D:[[@LINE+2]]:8 (Definition) [type=Sizes::D] [typekind=Record] [sizeof=8] [alignof=4]
-// CHECK32: StructDecl=D:[[@LINE+1]]:8 (Definition) [type=Sizes::D] [typekind=Record] [sizeof=8] [alignof=4]
+// CHECK64: StructDecl=D:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::D] [typekind=Record] [sizeof=8] [alignof=4]
+// CHECK32: StructDecl=D:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::D] [typekind=Record] [sizeof=8] [alignof=4]
 struct D : C {
   char c;
 };
 
-// CHECK64: StructDecl=E:[[@LINE+2]]:32 (Definition) [type=Sizes::E] [typekind=Record] [sizeof=5] [alignof=1]
-// CHECK32: StructDecl=E:[[@LINE+1]]:32 (Definition) [type=Sizes::E] [typekind=Record] [sizeof=5] [alignof=1]
+// CHECK64: StructDecl=E:[[@LINE+2]]:32 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::E] [typekind=Record] [sizeof=5] [alignof=1]
+// CHECK32: StructDecl=E:[[@LINE+1]]:32 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::E] [typekind=Record] [sizeof=5] [alignof=1]
 struct __attribute__((packed)) E {
   char b;
   int a;
 };
 
-// CHECK64: StructDecl=F:[[@LINE+2]]:32 (Definition) [type=Sizes::F] [typekind=Record] [sizeof=6] [alignof=1]
-// CHECK32: StructDecl=F:[[@LINE+1]]:32 (Definition) [type=Sizes::F] [typekind=Record] [sizeof=6] [alignof=1]
+// CHECK64: StructDecl=F:[[@LINE+2]]:32 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::F] [typekind=Record] [sizeof=6] [alignof=1]
+// CHECK32: StructDecl=F:[[@LINE+1]]:32 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::F] [typekind=Record] [sizeof=6] [alignof=1]
 struct __attribute__((packed)) F : E {
   char d;
 };
 
 struct G { G(); };
-// CHECK64: StructDecl=H:[[@LINE+2]]:8 (Definition) [type=Sizes::H] [typekind=Record] [sizeof=1] [alignof=1]
-// CHECK32: StructDecl=H:[[@LINE+1]]:8 (Definition) [type=Sizes::H] [typekind=Record] [sizeof=1] [alignof=1]
+// CHECK64: StructDecl=H:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::H] [typekind=Record] [sizeof=1] [alignof=1]
+// CHECK32: StructDecl=H:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Sizes::H] [typekind=Record] [sizeof=1] [alignof=1]
 struct H : G { };
 
-// CHECK64: StructDecl=I:[[@LINE+2]]:8 (Definition) [type=Sizes::I] [typekind=Record] [sizeof=5] [alignof=1]
-// CHECK32: StructDecl=I:[[@LINE+1]]:8 (Definition) [type=Sizes::I] [typekind=Record] [sizeof=5] [alignof=1]
+// CHECK64: StructDecl=I:[[@LINE+2]]:8 (Definition) (needs cassign) (needs massign) [type=Sizes::I] [typekind=Record] [sizeof=5] [alignof=1]
+// CHECK32: StructDecl=I:[[@LINE+1]]:8 (Definition) (needs cassign) (needs massign) [type=Sizes::I] [typekind=Record] [sizeof=5] [alignof=1]
 struct I {
   char b;
   int a;
 } __attribute__((packed));
 
 }
 
 namespace Test1 {
 
 // Test complex class hierarchy
 struct A { };
 struct B : A { virtual void b(); };
 class C : virtual A { int c; };
 struct D : virtual B { };
 struct E : C, virtual D { };
 class F : virtual E { };
-// CHECK64: StructDecl=G:[[@LINE+2]]:8 (Definition) [type=Test1::G] [typekind=Record] [sizeof=24] [alignof=8]
-// CHECK32: StructDecl=G:[[@LINE+1]]:8 (Definition) [type=Test1::G] [typekind=Record] [sizeof=16] [alignof=4]
+// CHECK64: StructDecl=G:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) [type=Test1::G] [typekind=Record] [sizeof=24] [alignof=8]
+// CHECK32: StructDecl=G:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) [type=Test1::G] [typekind=Record] [sizeof=16] [alignof=4]
 struct G : virtual E, F { };
 
 }
 
 namespace Test2 {
 
 // Test that this somewhat complex class structure is laid out correctly.
 struct A { };
 struct B : A { virtual void b(); };
 struct C : virtual B { };
 struct D : virtual A { };
 struct E : virtual B, D { };
 struct F : E, virtual C { };
 struct G : virtual F, A { };
-// CHECK64: StructDecl=H:[[@LINE+2]]:8 (Definition) [type=Test2::H] [typekind=Record] [sizeof=24] [alignof=8]
-// CHECK32: StructDecl=H:[[@LINE+1]]:8 (Definition) [type=Test2::H] [typekind=Record] [sizeof=12] [alignof=4]
+// CHECK64: StructDecl=H:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Test2::H] [typekind=Record] [sizeof=24] [alignof=8]
+// CHECK32: StructDecl=H:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=Test2::H] [typekind=Record] [sizeof=12] [alignof=4]
 struct H { G g; };
 
 }
 
 namespace Test3 {
 // CHECK64: ClassDecl=B:[[@LINE+2]]:7 (Definition) [type=Test3::B] [typekind=Record] [sizeof=16] [alignof=8]
 // CHECK32: ClassDecl=B:[[@LINE+1]]:7 (Definition) [type=Test3::B] [typekind=Record] [sizeof=8] [alignof=4]
 class B {

 
 Foo<Sizes::A> t1;
 Foo<Sizes::I> t2;
 
 void c;
 
 plopplop;
 
-// CHECK64: StructDecl=lastValid:[[@LINE+2]]:8 (Definition) [type=CrashTest::lastValid] [typekind=Record] [sizeof=1] [alignof=1]
-// CHECK32: StructDecl=lastValid:[[@LINE+1]]:8 (Definition) [type=CrashTest::lastValid] [typekind=Record] [sizeof=1] [alignof=1]
+// CHECK64: StructDecl=lastValid:[[@LINE+2]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=CrashTest::lastValid] [typekind=Record] [sizeof=1] [alignof=1]
+// CHECK32: StructDecl=lastValid:[[@LINE+1]]:8 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=CrashTest::lastValid] [typekind=Record] [sizeof=1] [alignof=1]
 struct lastValid {
 };
 
 // CHECK64: CXXMethod=Tie:[[@LINE+3]]:8 (const) [type=auto (void *) const] [typekind=FunctionProto] [sizeof=1] [alignof=4] [resulttype=auto] [resulttypekind=Auto] [resultsizeof=-6] [resultalignof=-6]
 // CHECK32: CXXMethod=Tie:[[@LINE+2]]:8 (const) [type=auto (void *) const] [typekind=FunctionProto] [sizeof=1] [alignof=4] [resulttype=auto] [resulttypekind=Auto] [resultsizeof=-6] [resultalignof=-6]
 class BrowsingContext {
   auto Tie(void*) const;
 };
 
 }

clang/test/Index/print-type.cpp

 // CHECK: TemplateTypeParameter=T:3:19 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: FieldDecl=t:5:5 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: TypeRef=T:3:19 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: ClassTemplate=Baz:9:8 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:8:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: NonTypeTemplateParameter=U:8:32 (Definition) [type=unsigned int] [typekind=UInt] [isPOD=1]
 // CHECK: TemplateTemplateParameter=W:8:60 (Definition) [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: Namespace=inner:14:11 (Definition) [type=] [typekind=Invalid] [isPOD=0]
-// CHECK: StructDecl=Bar:16:8 (Definition) [type=outer::inner::Bar] [typekind=Record] [isPOD=0] [nbFields=3]
+// CHECK: StructDecl=Bar:16:8 (Definition) (needs cassign) (needs massign) (needs dtor) [type=outer::inner::Bar] [typekind=Record] [isPOD=0] [nbFields=3]
 // CHECK: CXXConstructor=Bar:17:3 (Definition) (converting constructor) [type=void (outer::Foo<bool> *){{.*}}] [typekind=FunctionProto] [canonicaltype=void (outer::Foo<bool> *){{.*}}] [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0]
 // CHECK: ParmDecl=foo:17:25 (Definition) [type=outer::Foo<bool> *] [typekind=Pointer] [canonicaltype=outer::Foo<bool> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=outer::Foo<bool>] [pointeekind=Elaborated]
 // CHECK: NamespaceRef=outer:1:11 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: CompoundStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TypedefDecl=FooType:19:15 (Definition) [type=outer::inner::Bar::FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: TypeAliasDecl=AliasType:20:9 (Definition) [type=outer::inner::Bar::AliasType] [typekind=Typedef] [canonicaltype=double] [canonicaltypekind=Double] [isPOD=1]
 // CHECK: FieldDecl=p:21:8 (Definition) [type=int *] [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]

 // CHECK: DeclRefExpr=size:41:27 [type=int] [typekind=Int] [isPOD=1]
 // CHECK: FunctionDecl=foo:44:6 (Definition) [type=void (int, int *)] [typekind=FunctionProto] [canonicaltype=void (int, int *)] [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [int] [Int] [int[]] [IncompleteArray]] [isPOD=0]
 // CHECK: ParmDecl=i:44:14 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: ParmDecl=incomplete_array:44:21 (Definition) [type=int[]] [typekind=IncompleteArray] [isPOD=1]
 // CHECK: CompoundStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: DeclStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: VarDecl=variable_array:44:47 (Definition) [type=int[i]] [typekind=VariableArray] [isPOD=1]
 // CHECK: DeclRefExpr=i:44:14 [type=int] [typekind=Int] [isPOD=1]
-// CHECK: StructDecl=Blob:46:8 (Definition) [type=Blob] [typekind=Record] [isPOD=1] [nbFields=2]
+// CHECK: StructDecl=Blob:46:8 (Definition) (needs cassign) (needs massign) (needs dtor) [type=Blob] [typekind=Record] [isPOD=1] [nbFields=2]
 // CHECK: FieldDecl=i:47:7 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: VarDecl=member_pointer:50:12 (Definition) [type=int Blob::*] [typekind=MemberPointer] [isPOD=1]
 // CHECK: FunctionDecl=elaboratedNamespaceType:52:42 [type=NS::Type (const NS::Type)] [typekind=FunctionProto] [canonicaltype=NS::Type (NS::Type)] [canonicaltypekind=FunctionProto] [resulttype=NS::Type] [resulttypekind=Elaborated] [args= [const NS::Type] [Elaborated]] [isPOD=0]
 // CHECK: NamespaceRef=NS:52:11 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TypeRef=struct NS::Type:52:23 [type=NS::Type] [typekind=Record] [isPOD=1]
 // CHECK: ParmDecl=t:52:81 (Definition) [type=const NS::Type] [typekind=Elaborated] const [canonicaltype=const NS::Type] [canonicaltypekind=Record] [isPOD=1]
 // CHECK: VarDecl=autoI:54:6 (Definition) [type=int] [typekind=Auto] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]

 // CHECK: TemplateRef=Specialization:66:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: CallExpr=Specialization:66:8 [type=Specialization<Specialization<bool> &>] [typekind=Elaborated] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: VarDecl=autoTemplRefParam:72:6 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Auto] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: UnexposedExpr=templRefParam:71:40 [type=const Specialization<Specialization<bool> &>] [typekind=Record] const [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: DeclRefExpr=templRefParam:71:40 [type=Specialization<Specialization<bool> &>] [typekind=Elaborated] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: TypeAliasDecl=baz:76:7 (Definition) [type=baz] [typekind=Typedef] [templateargs/1= [type=A<void>] [typekind=Elaborated]] [canonicaltype=A<void>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=void] [typekind=Void]] [isPOD=0]
 // CHECK: VarDecl=autoTemplPointer:78:6 (Definition) [type=Specialization<Specialization<bool> &> *] [typekind=Auto] [canonicaltype=Specialization<Specialization<bool> &> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Specialization<Specialization<bool> &>] [pointeekind=Auto]
 // CHECK: CallExpr=Bar:17:3 [type=outer::inner::Bar] [typekind=Elaborated] [canonicaltype=outer::inner::Bar] [canonicaltypekind=Record] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0] [nbFields=3]
-// CHECK: StructDecl=:84:3 (Definition) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
-// CHECK: ClassDecl=:85:3 (Definition) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
+// CHECK: StructDecl=:84:3 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
+// CHECK: ClassDecl=:85:3 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: UnionDecl=:86:3 (Definition) [type=X::(anonymous union at {{.*}}print-type.cpp:86:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1]
 // CHECK: EnumDecl=:87:3 (Definition) [type=X::(unnamed enum at {{.*}}print-type.cpp:87:3)] [typekind=Enum] [isPOD=1] [isAnon=1]
 // CHECK: Namespace=:90:11 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnon=1]
 // CHECK: Namespace=InlineNS:94:18 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnonRecDecl=0] [isInlineNamespace=1]

clang/test/Index/recursive-cxx-member-calls.cpp

 // CHECK: 7:26: ParmDecl=:7:26 (Definition) Extent=[7:14 - 7:26]
 // CHECK: 7:40: ParmDecl=:7:40 (Definition) Extent=[7:28 - 7:40]
 // CHECK: 7:48: ParmDecl=:7:48 (Definition) Extent=[7:42 - 7:48]
 // CHECK: 7:42: TypeRef=size_t:2:25 Extent=[7:42 - 7:48]
 // CHECK: 8:10: FunctionDecl=strlen:8:10 Extent=[8:3 - 8:30]
 // CHECK: 8:3: TypeRef=size_t:2:25 Extent=[8:3 - 8:9]
 // CHECK: 8:29: ParmDecl=:8:29 (Definition) Extent=[8:17 - 8:29]
 // CHECK: 10:17: Namespace=clang:10:17 (Definition) Extent=[10:1 - 35:2]
-// CHECK: 11:9: ClassDecl=IdentifierInfo:11:9 Extent=[11:3 - 11:23]
-// CHECK: 12:9: ClassDecl=AttributeList:12:9 (Definition) Extent=[12:3 - 34:4]
+// CHECK: 11:9: ClassDecl=IdentifierInfo:11:9 (needs cassign) (needs massign) (needs dtor) Extent=[11:3 - 11:23]
+// CHECK: 12:9: ClassDecl=AttributeList:12:9 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[12:3 - 34:4]
 // CHECK: 13:10: EnumDecl=Kind:13:10 (Definition) Extent=[13:5 - 32:6]
 // CHECK: 14:7: EnumConstantDecl=AT_IBAction:14:7 (Definition) Extent=[14:7 - 14:18]
 // CHECK: 14:20: EnumConstantDecl=AT_IBOutlet:14:20 (Definition) Extent=[14:20 - 14:31]
 // CHECK: 14:33: EnumConstantDecl=AT_IBOutletCollection:14:33 (Definition) Extent=[14:33 - 14:54]
 // CHECK: 15:7: EnumConstantDecl=AT_address_space:15:7 (Definition) Extent=[15:7 - 15:23]
 // CHECK: 15:25: EnumConstantDecl=AT_alias:15:25 (Definition) Extent=[15:25 - 15:33]
 // CHECK: 15:35: EnumConstantDecl=AT_aligned:15:35 (Definition) Extent=[15:35 - 15:45]
 // CHECK: 15:47: EnumConstantDecl=AT_always_inline:15:47 (Definition) Extent=[15:47 - 15:63]

 // CHECK: 33:17: CXXMethod=getKind:33:17 (static) Extent=[33:5 - 33:53]
 // CHECK: 33:12: TypeRef=enum clang::AttributeList::Kind:13:10 Extent=[33:12 - 33:16]
 // CHECK: 33:48: ParmDecl=Name:33:48 (Definition) Extent=[33:25 - 33:52]
 // CHECK: 33:31: TypeRef=class clang::IdentifierInfo:66:7 Extent=[33:31 - 33:45]
 // CHECK: 36:8: FunctionDecl=magic_length:36:8 Extent=[36:1 - 36:35]
 // CHECK: 36:1: TypeRef=size_t:2:25 Extent=[36:1 - 36:7]
 // CHECK: 36:33: ParmDecl=s:36:33 (Definition) Extent=[36:21 - 36:34]
 // CHECK: 37:11: Namespace=llvm:37:11 (Definition) Extent=[37:1 - 64:2]
-// CHECK: 38:7: ClassDecl=StringRef:38:7 (Definition) Extent=[38:1 - 63:2]
+// CHECK: 38:7: ClassDecl=StringRef:38:7 (Definition) (needs massign) Extent=[38:1 - 63:2]
 // CHECK: 39:1: CXXAccessSpecifier=:39:1 (Definition) Extent=[39:1 - 39:8]
 // CHECK: 40:23: TypedefDecl=iterator:40:23 (Definition) Extent=[40:3 - 40:31]
 // CHECK: 41:23: VarDecl=npos:41:23 Extent=[41:3 - 41:40]
 // CHECK: 41:16: TypeRef=size_t:2:25 Extent=[41:16 - 41:22]
 // CHECK: 41:30: UnaryOperator= Extent=[41:30 - 41:40]
 // CHECK: 41:31: CXXFunctionalCastExpr= Extent=[41:31 - 41:40]
 // CHECK: 41:31: TypeRef=size_t:2:25 Extent=[41:31 - 41:37]
 // CHECK: 41:38: UnexposedExpr= Extent=[41:38 - 41:39]

 // CHECK: 61:36: UnexposedExpr=min:45:17 Extent=[61:36 - 61:39]
 // CHECK: 61:36: DeclRefExpr=min:45:17 Extent=[61:36 - 61:39]
 // CHECK: 61:40: DeclRefExpr=N:60:41 Extent=[61:40 - 61:41]
 // CHECK: 61:43: BinaryOperator= Extent=[61:43 - 61:57]
 // CHECK: 61:43: UnexposedExpr=Length:44:10 Extent=[61:43 - 61:49]
 // CHECK: 61:43: MemberRefExpr=Length:44:10 Extent=[61:43 - 61:49]
 // CHECK: 61:52: DeclRefExpr=Start:60:27 Extent=[61:52 - 61:57]
 // CHECK: 65:11: Namespace=clang:65:11 (Definition) Extent=[65:1 - 81:2]
-// CHECK: 66:7: ClassDecl=IdentifierInfo:66:7 (Definition) Extent=[66:1 - 80:2]
+// CHECK: 66:7: ClassDecl=IdentifierInfo:66:7 (Definition) (needs cassign) (needs massign) (needs dtor) Extent=[66:1 - 80:2]
 // CHECK: 67:1: CXXAccessSpecifier=:67:1 (Definition) Extent=[67:1 - 67:8]
 // CHECK: 67:8: CXXConstructor=IdentifierInfo:67:8 (default constructor) Extent=[67:8 - 67:24]
 // CHECK: 68:15: CXXMethod=getNameStart:68:15 (Definition) (const) Extent=[68:3 - 71:4] [access=public]
 // CHECK: 68:36: CompoundStmt= Extent=[68:36 - 71:4]
 // CHECK: 69:5: DeclStmt= Extent=[69:5 - 69:65]
 // CHECK: 69:54: TypedefDecl=actualtype:69:54 (Definition) Extent=[69:5 - 69:64]
 // CHECK: 69:18: TemplateRef=pair:4:44 Extent=[69:18 - 69:22]
 // CHECK: 69:25: TypeRef=class clang::IdentifierInfo:66:7 Extent=[69:25 - 69:39]

clang/test/Index/redeclarations.cpp

 #include "redeclarations.h"
 
 class A
 {
 };
 
 // RUN: env CINDEXTEST_EDITING=1 c-index-test -test-load-source-reparse 2 all -I%S/Inputs -fno-delayed-template-parsing -fno-ms-compatibility -fno-ms-extensions %s | FileCheck %s
 
-// CHECK: redeclarations.h:1:7: ClassDecl=X:1:7 (Definition) Extent=[1:1 - 4:2]
+// CHECK: redeclarations.h:1:7: ClassDecl=X:1:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[1:1 - 4:2]
 // CHECK: redeclarations.h:8:7: ClassTemplate=B:8:7 (Definition) Extent=[7:1 - 10:2]
 // CHECK: redeclarations.h:7:20: TemplateTypeParameter=T1:7:20 (Definition) Extent=[7:11 - 7:22]
 // CHECK: redeclarations.h:7:33: TemplateTypeParameter=T2:7:33 (Definition) Extent=[7:24 - 7:35]
 // CHECK: redeclarations.h:13:8: ClassTemplate=C:13:8 (Definition) Extent=[12:1 - 15:2]
 // CHECK: redeclarations.h:12:17: TemplateTypeParameter=T:12:17 (Definition) Extent=[12:11 - 12:18]
-// CHECK: redeclarations.h:17:7: ClassDecl=D:17:7 (Definition) Extent=[17:1 - 21:2]
-// CHECK: redeclarations.h:19:16: ClassDecl=A:19:16 Extent=[19:10 - 19:17]
+// CHECK: redeclarations.h:17:7: ClassDecl=D:17:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[17:1 - 21:2]
+// CHECK: redeclarations.h:19:16: ClassDecl=A:19:16 (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[19:10 - 19:17]
 // CHECK: redeclarations.h:19:19: FieldDecl=x:19:19 (Definition) Extent=[19:5 - 19:20]
 // CHECK: redeclarations.h:19:5: TemplateRef=B:8:7 Extent=[19:5 - 19:6]
 // CHECK: redeclarations.h:19:7: TypeRef=class D:17:7 Extent=[19:7 - 19:8]
 // CHECK: redeclarations.h:19:16: TypeRef=class A:3:7 Extent=[19:16 - 19:17]
-// CHECK: redeclarations.cpp:3:7: ClassDecl=A:3:7 (Definition) Extent=[3:1 - 5:2]
+// CHECK: redeclarations.cpp:3:7: ClassDecl=A:3:7 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[3:1 - 5:2]

clang/test/Parser/skip-function-bodies.mm

 }
 @end
 
 void J() {
   class K {};
 }
 
 // RUN: env CINDEXTEST_SKIP_FUNCTION_BODIES=1 c-index-test -test-load-source all %s | FileCheck %s
-// CHECK: skip-function-bodies.mm:3:7: ClassDecl=A:3:7 (Definition) Extent=[3:1 - 14:2]
-// CHECK: skip-function-bodies.mm:4:9: ClassDecl=B:4:9 (Definition) Extent=[4:3 - 4:13]
+// CHECK: skip-function-bodies.mm:3:7: ClassDecl=A:3:7 (Definition) (needs cassign) (needs massign) (needs dtor) Extent=[3:1 - 14:2]
+// CHECK: skip-function-bodies.mm:4:9: ClassDecl=B:4:9 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[4:3 - 4:13]
 // CHECK: skip-function-bodies.mm:6:1: CXXAccessSpecifier=:6:1 (Definition) Extent=[6:1 - 6:8]
 // CHECK: skip-function-bodies.mm:7:3: CXXConstructor=A:7:3 (default constructor) Extent=[7:3 - 7:6]
-// CHECK-NOT: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
+// CHECK-NOT: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[8:5 - 10:6]
 // CHECK-NOT: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]
 // CHECK: skip-function-bodies.mm:13:13: TypedefDecl=E:13:13 (Definition) Extent=[13:3 - 13:14]
 // CHECK: skip-function-bodies.mm:13:11: TypeRef=class A::B:4:9 Extent=[13:11 - 13:12]
 // CHECK: skip-function-bodies.mm:16:12: ObjCInterfaceDecl=F:16:12 Extent=[16:1 - 18:5]
 // CHECK: skip-function-bodies.mm:17:10: ObjCInstanceMethodDecl=G:17:10 Extent=[17:1 - 17:12]
 // CHECK: skip-function-bodies.mm:19:17: ObjCImplementationDecl=F:19:17 (Definition) Extent=[19:1 - 24:2]
 // CHECK: skip-function-bodies.mm:20:10: ObjCInstanceMethodDecl=G:20:10 Extent=[20:1 - 20:13]
 // CHECK-NOT: skip-function-bodies.mm:21:13: TypedefDecl=H:21:13 (Definition) Extent=[21:3 - 21:14]
 // CHECK-NOT: skip-function-bodies.mm:21:11: TypeRef=class A:3:7 Extent=[21:11 - 21:12]
 // CHECK: skip-function-bodies.mm:26:6: FunctionDecl=J:26:6 Extent=[26:1 - 26:9]
 // CHECK-NOT: skip-function-bodies.mm:27:9: ClassDecl=K:27:9 (Definition) Extent=[27:3 - 27:13]
 
 // RUN: env CINDEXTEST_EDITING=1 \
 // RUN:  CINDEXTEST_CREATE_PREAMBLE_ON_FIRST_PARSE=1 \
 // RUN:  CINDEXTEST_SKIP_FUNCTION_BODIES=1 \
 // RUN:  CINDEXTEST_LIMIT_SKIP_FUNCTION_BODIES_TO_PREAMBLE=1 \
 // RUN:  c-index-test -test-load-source all %s | FileCheck -check-prefix=CHECK-PREAMBLE %s
 // CHECK-PREAMBLE: skip-function-bodies.h:1:5: FunctionDecl=header1:1:5 Extent=[1:1 - 1:19]
 // CHECK-PREAMBLE-NOT: skip-function-bodies.h:2:3: ReturnStmt= Extent=[2:3 - 2:11]
-// CHECK-PREAMBLE: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) Extent=[8:5 - 10:6]
+// CHECK-PREAMBLE: skip-function-bodies.mm:8:12: StructDecl=C:8:12 (Definition) (needs ctor) (needs cctor) (needs mctor) (needs cassign) (needs massign) (needs dtor) Extent=[8:5 - 10:6]
 // CHECK-PREAMBLE: skip-function-bodies.mm:9:12: CXXMethod=d:9:12 (Definition) Extent=[9:7 - 9:18]

clang/tools/c-index-test/c-index-test.c

else {
     if (clang_EnumDecl_isScoped(Cursor))
       printf(" (scoped)");
     if (clang_Cursor_isVariadic(Cursor))
       printf(" (variadic)");
     if (clang_Cursor_isObjCOptional(Cursor))
       printf(" (@optional)");
     if (clang_isInvalidDeclaration(Cursor))
       printf(" (invalid)");
+    if (clang_CXXRecord_defaultedCopyConstructorIsDeleted(Cursor))
+      printf(" (default-deleted cctor)");
+    if (clang_CXXRecord_defaultedMoveConstructorIsDeleted(Cursor))
+      printf(" (default-deleted mctor)");
+    if (clang_CXXRecord_defaultedDestructorIsDeleted(Cursor))
+      printf(" (default-deleted dtor)");
+    if (clang_CXXRecord_needsImplicitDefaultConstructor(Cursor))
+      printf(" (needs ctor)");
+    if (clang_CXXRecord_needsImplicitCopyConstructor(Cursor))
+      printf(" (needs cctor)");
+    if (clang_CXXRecord_needsImplicitMoveConstructor(Cursor))
+      printf(" (needs mctor)");
+    if (clang_CXXRecord_needsImplicitCopyAssignment(Cursor))
+      printf(" (needs cassign)");
+    if (clang_CXXRecord_needsImplicitMoveAssignment(Cursor))
+      printf(" (needs massign)");
+    if (clang_CXXRecord_needsImplicitDestructor(Cursor))
+      printf(" (needs dtor)");
 
     switch (clang_getCursorExceptionSpecificationType(Cursor))
     {
       case CXCursor_ExceptionSpecificationKind_None:
         break;
 
       case CXCursor_ExceptionSpecificationKind_DynamicNone:
         printf(" (noexcept dynamic none)");

clang/tools/libclang/CIndex.cpp

 //===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
unsigned clang_CXXRecord_isAbstract(CXCursor C) {
 
   const auto *D = cxcursor::getCursorDecl(C);
   const auto *RD = dyn_cast_or_null<CXXRecordDecl>(D);
   if (RD)
     RD = RD->getDefinition();
   return (RD && RD->isAbstract()) ? 1 : 0;
 }
 
+unsigned clang_CXXRecord_defaultedCopyConstructorIsDeleted(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD && !RD->isUnion())
+    RD = RD->getDefinition();
+  return (RD && RD->defaultedCopyConstructorIsDeleted()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_defaultedMoveConstructorIsDeleted(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->defaultedMoveConstructorIsDeleted()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_defaultedDestructorIsDeleted(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->defaultedDestructorIsDeleted()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_needsImplicitDefaultConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->needsImplicitDefaultConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_needsImplicitCopyConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->needsImplicitDefaultConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_needsImplicitCopyAssignment(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->needsImplicitCopyAssignment()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_needsImplicitMoveConstructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->needsImplicitDefaultConstructor()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_needsImplicitMoveAssignment(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->needsImplicitMoveAssignment()) ? 1 : 0;
+}
+
+unsigned clang_CXXRecord_needsImplicitDestructor(CXCursor C) {
+  if (!clang_isDeclaration(C.kind))
+    return 0;
+
+  const auto *D = cxcursor::getCursorDecl(C);
+  const auto *RD = dyn_cast_if_present<CXXRecordDecl>(D);
+  if (RD)
+    RD = RD->getDefinition();
+  return (RD && !RD->isUnion() && RD->needsImplicitDestructor()) ? 1 : 0;
+}
+
 unsigned clang_EnumDecl_isScoped(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return 0;
 
   const Decl *D = cxcursor::getCursorDecl(C);
   auto *Enum = dyn_cast_or_null<EnumDecl>(D);
   return (Enum && Enum->isScoped()) ? 1 : 0;
 }

clang/tools/libclang/libclang.map

LLVM_13 {
   local: *;
 };
 
 LLVM_16 {
   global:
     clang_getUnqualifiedType;
     clang_getNonReferenceType;
     clang_CXXMethod_isDeleted;
+    clang_CXXRecord_defaultedCopyConstructorIsDeleted;
+    clang_CXXRecord_defaultedMoveConstructorIsDeleted;
+    clang_CXXRecord_defaultedDestructorIsDeleted;
+    clang_CXXRecord_needsImplicitDefaultConstructor;
+    clang_CXXRecord_needsImplicitCopyConstructor;
+    clang_CXXRecord_needsImplicitCopyAssignment;
+    clang_CXXRecord_needsImplicitMoveConstructor;
+    clang_CXXRecord_needsImplicitMoveAssignment;
+    clang_CXXRecord_needsImplicitDestructor;
 };
 
 # Example of how to add a new symbol version entry.  If you do add a new symbol
 # version, please update the example to depend on the version you added.
 # LLVM_X {
 # global:
 #   clang_newsymbol;
 # };