[Sema] TypeWrappers: If type wrapper comes from .swiftinterface use synthesized decls

Swift interfaces have both attribute and all publicly accessible
synthesized members, which means that the synthesis needs to be
taught to lookup existing synthesized declarations for `$storage`,
`$Storage`, and `init(storageWrapper:)` if request comes for
declaration that belongs to a Swift interface file.

Author: xedin

lib/Sema/CodeSynthesis.cpp

@@ -1657,14 +1657,29 @@ ConstructorDecl *SynthesizeTypeWrappedTypeStorageWrapperInitializer::evaluate(
   if (!wrappedType->hasTypeWrapper())
     return nullptr;
 
+  auto &ctx = wrappedType->getASTContext();
+
+  // .swiftinterfaces have both attribute and a synthesized member
+  // (if it's public), so in this case we need use existing declaration
+  // if available.
+  {
+    auto parentSF = wrappedType->getDeclContext()->getParentSourceFile();
+    if (parentSF && parentSF->Kind == SourceFileKind::Interface) {
+      DeclName initName(ctx, DeclBaseName::createConstructor(),
+                        /*labels=*/{ctx.Id_storageWrapper});
+      auto results = wrappedType->lookupDirect(initName);
+      if (results.size() == 1)
+        return cast<ConstructorDecl>(results.front());
+    }
+  }
+
   // `@typeWrapperIgnored` properties suppress this initializer.
   if (llvm::any_of(wrappedType->getMembers(), [&](Decl *member) {
         return member->getAttrs().hasAttribute<TypeWrapperIgnoredAttr>();
       }))
     return nullptr;
 
   // Create the implicit type wrapper storage constructor.
-  auto &ctx = wrappedType->getASTContext();
   auto ctor = createImplicitConstructor(
       wrappedType, ImplicitConstructorKind::TypeWrapperStorage, ctx);
   wrappedType->addMember(ctor);

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -26,6 +26,17 @@
 
 using namespace swift;
 
+/// Check whether given declaration comes from the .swiftinterface file.
+static bool inSwiftInterfaceContext(NominalTypeDecl *typeDecl) {
+  auto *SF = typeDecl->getDeclContext()->getParentSourceFile();
+  return SF && SF->Kind == SourceFileKind::Interface;
+}
+
+static ValueDecl *findMember(NominalTypeDecl *typeDecl, Identifier memberName) {
+  auto members = typeDecl->lookupDirect(memberName);
+  return members.size() == 1 ? members.front() : nullptr;
+}
+
 static PatternBindingDecl *injectVariable(DeclContext *DC, Identifier name,
                                           Type type,
                                           VarDecl::Introducer introducer,
@@ -284,6 +295,15 @@ TypeDecl *GetTypeWrapperStorage::evaluate(Evaluator &evaluator,
 
   auto &ctx = parent->getASTContext();
 
+  // .swiftinterfaces have both attribute and a synthesized member
+  // (if it's public), so in this case we need use existing declaration
+  // if available.
+  if (inSwiftInterfaceContext(parent)) {
+    if (auto *storage = dyn_cast_or_null<TypeDecl>(
+            findMember(parent, ctx.Id_TypeWrapperStorage)))
+      return storage;
+  }
+
   TypeDecl *storage = nullptr;
   if (isa<ProtocolDecl>(parent)) {
     // If type wrapper is associated with a protocol, we need to
@@ -320,6 +340,15 @@ GetTypeWrapperProperty::evaluate(Evaluator &evaluator,
   if (!typeWrapper)
     return nullptr;
 
+  // .swiftinterfaces have both attribute and a synthesized member
+  // (if it's public), so in this case we need use existing declaration
+  // if available.
+  if (inSwiftInterfaceContext(parent)) {
+    if (auto *storage = dyn_cast_or_null<VarDecl>(
+            findMember(parent, ctx.Id_TypeWrapperProperty)))
+      return storage;
+  }
+
   auto *storage = parent->getTypeWrapperStorageDecl();
   assert(storage);