[cxx-interop] Import the attributes from clang decl for synthesized s…

[fahadnayyar]

Attributes like availability were not being copied from clang decl of C++ operator * to swift decl of pointee property. Because of this pointee property was not hidden in swift even if C++ operator * (dereference operator) was marked with attribute((availability(swift, unavailable))).

rdar://116775023

[fahadnayyar]

@swift-ci Please smoke test

[fahadnayyar]

@swift-ci Please test

[ravikandhadai]

This logic looks quite specific to the synthesized pointee property. Are there other synthesized properties where this is necessary? If so, I wonder if we can factor this out in to a method and call this from other places as well.

[fahadnayyar]

I discussed this with @egorzhdan and @beccadax . I think this problem should be there for other synthesized properties also (like computed properties). But I wanted to get feedback from people by making a patch only for pointee property and then think about solving this problem in general for all synthesized properties.

[egorzhdan]

Thanks @fahadnayyar! The overall logic looks good to me, but I have a couple comments.

[egorzhdan]

Can getterImpl->getClangDecl() ever be null? Looks like it would always be non-null, so I think we should just unconditionally cast<clang::NamedDecl> and have an assertion if the getter's Clang decl ended up being null, since that would indicate a problem in our reasoning about this code path.

[fahadnayyar]

Yes, getterImpl->getClangDecl() was null for some lit test cases like these:

// ***------- TEST 1
// Swift:

let derivedConstIterWithUD = DerivedFromConstIteratorPrivatelyWithUsingDecl()
let _ = derivedConstIterWithUD.pointee

// C++:

struct ConstIterator {
private:
  int value = 234;
public:
    int &operator*() { return value; }
};
struct DerivedFromConstIteratorPrivatelyWithUsingDecl : private ConstIterator {
  using ConstIterator::operator*;
};

// ***------- TEST 2
// Swift:

let stars = DerivedFromConstIteratorPrivatelyWithUsingDecl()
let res = stars.pointee

// C++:

struct ConstIterator {
private:
  int value = 234;
public:
  const int &operator*() const { return value; }
};
struct DerivedFromConstIteratorPrivatelyWithUsingDecl : private ConstIterator {
  using ConstIterator::operator*;
};

// ***------- TEST 3
// Swift:

let stars = DerivedFromAmbiguousOperatorStarPrivatelyWithUsingDecl()
let res = stars.pointee

// C++:

struct AmbiguousOperatorStar {
private:
  int value = 567;
public:
  int &operator*() { return value; }
  const int &operator*() const { return value; }
};
struct DerivedFromAmbiguousOperatorStarPrivatelyWithUsingDecl
    : private AmbiguousOperatorStar {
  using AmbiguousOperatorStar::operator*;
};

So maybe the problem is when calling pointee property C++ types which inherits operator* from their parent/base class like using AmbiguousOperatorStar::operator* and using ConstIterator::operator*
@egorzhdan do you have thoughts about why getterImpl->getClangDecl() is null for these cases? I was assuming that __myoperatorstar function should always have a clangDecl from which it is mapped.

[egorzhdan]

Oh right, that makes sense. C++ members that were instantiated from using-shadow-decls have no corresponding Clang decl. This is because we synthesize a Swift decl that dispatches the call to the underlying Clang decl.
(Ideally we would synthesize a decl on the Clang side, not on the Swift side, to help us avoid this kind of issues)
Could you please add a comment mentioning the inheritance quirk?

[egorzhdan]

We don't import operator-> into Swift, so this decl is ignored.
(It's OK to keep it in the test if you'd like, just FYI)

[egorzhdan]

Oh right, that makes sense. C++ members that were instantiated from using-shadow-decls have no corresponding Clang decl. This is because we synthesize a Swift decl that dispatches the call to the underlying Clang decl.
(Ideally we would synthesize a decl on the Clang side, not on the Swift side, to help us avoid this kind of issues)
Could you please add a comment mentioning the inheritance quirk?

[egorzhdan]

Could you please add a test that checks that inherited operator* gets the correct attributes, e.g. struct DerivedHasOperatorStar : HasOperatorStar

[egorzhdan]

Minor: let's remove the func wrappers to keep this consistent with the rest of the test

[egorzhdan]

Minor: let's capitalize Swift.