Merge pull request swiftlang#33573 from brentdax/how-forward-of-you-2-electric-boogaloo

Support generic @compatibility_alias in PrintAsObjC

Author: beccadax

include/swift/AST/ClangNode.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_CLANGNODE_H
 #define SWIFT_CLANGNODE_H
 
+#include "swift/Basic/Debug.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace clang {
@@ -98,6 +99,8 @@ class ClangNode {
   clang::SourceLocation getLocation() const;
   clang::SourceRange getSourceRange() const;
 
+  SWIFT_DEBUG_DUMP;
+
   void *getOpaqueValue() const { return Ptr.getOpaqueValue(); }
   static inline ClangNode getFromOpaqueValue(void *VP) {
     ClangNode N;

include/swift/AST/Decl.h

@@ -2996,11 +2996,29 @@ class TypeAliasDecl : public GenericTypeDecl {
   /// Retrieve a sugared interface type containing the structure of the interface
   /// type before any semantic validation has occured.
   Type getStructuralType() const;
-  
+
+  /// Whether the typealias forwards perfectly to its underlying type.
+  ///
+  /// If true, this typealias was created by ClangImporter to preserve source
+  /// compatibility with a previous language version's name for a type. Many
+  /// checks in Sema look through compatibility aliases even when they would
+  /// operate on other typealiases.
+  ///
+  /// \warning This has absolutely nothing to do with the Objective-C
+  /// \c compatibility_alias keyword.
   bool isCompatibilityAlias() const {
     return Bits.TypeAliasDecl.IsCompatibilityAlias;
   }
 
+  /// Sets whether the typealias forwards perfectly to its underlying type.
+  ///
+  /// Marks this typealias as having been created by ClangImporter to preserve
+  /// source compatibility with a previous language version's name for a type.
+  /// Many checks in Sema look through compatibility aliases even when they
+  /// would operate on other typealiases.
+  ///
+  /// \warning This has absolutely nothing to do with the Objective-C
+  /// \c compatibility_alias keyword.
   void markAsCompatibilityAlias(bool newValue = true) {
     Bits.TypeAliasDecl.IsCompatibilityAlias = newValue;
   }

lib/AST/Decl.cpp

@@ -116,6 +116,17 @@ const clang::Module *ClangNode::getClangModule() const {
   return nullptr;
 }
 
+void ClangNode::dump() const {
+  if (auto D = getAsDecl())
+    D->dump();
+  else if (auto M = getAsMacro())
+    M->dump();
+  else if (auto M = getAsModule())
+    M->dump();
+  else
+    llvm::errs() << "ClangNode contains nullptr\n";
+}
+
 // Only allow allocation of Decls using the allocator in ASTContext.
 void *Decl::operator new(size_t Bytes, const ASTContext &C,
                          unsigned Alignment) {

lib/PrintAsObjC/DeclAndTypePrinter.cpp

@@ -1572,25 +1572,36 @@ class DeclAndTypePrinter::Implementation
   }
 
   bool printImportedAlias(const TypeAliasDecl *alias,
+                          ArrayRef<Type> genericArgs,
                           Optional<OptionalTypeKind> optionalKind) {
     if (!alias->hasClangNode())
       return false;
 
     if (auto *clangTypeDecl =
           dyn_cast<clang::TypeDecl>(alias->getClangDecl())) {
+      assert(!alias->isGeneric()
+             && "generic typealias backed by clang typedecl?");
+
       maybePrintTagKeyword(alias);
       os << getNameForObjC(alias);
 
       if (isClangPointerType(clangTypeDecl))
         printNullability(optionalKind);
     } else if (auto *clangObjCClass
                = dyn_cast<clang::ObjCInterfaceDecl>(alias->getClangDecl())){
+      assert(!alias->isGeneric()
+             && "generic typealias backed by clang interface?");
+
       os << clangObjCClass->getName() << " *";
       printNullability(optionalKind);
     } else {
       auto *clangCompatAlias =
       cast<clang::ObjCCompatibleAliasDecl>(alias->getClangDecl());
-      os << clangCompatAlias->getName() << " *";
+
+      os << clangCompatAlias->getName();
+      if (!genericArgs.empty())
+        printGenericArgs(genericArgs);
+      os << " *";
       printNullability(optionalKind);
     }
 
@@ -1600,10 +1611,12 @@ class DeclAndTypePrinter::Implementation
   void visitTypeAliasType(TypeAliasType *aliasTy,
                                Optional<OptionalTypeKind> optionalKind) {
     const TypeAliasDecl *alias = aliasTy->getDecl();
+    auto genericArgs = aliasTy->getDirectGenericArgs();
+
     if (printIfKnownSimpleType(alias, optionalKind))
       return;
 
-    if (printImportedAlias(alias, optionalKind))
+    if (printImportedAlias(alias, genericArgs, optionalKind))
       return;
 
     visitPart(aliasTy->getSinglyDesugaredType(), optionalKind);
@@ -1737,8 +1750,12 @@ class DeclAndTypePrinter::Implementation
   }
 
   void printGenericArgs(BoundGenericType *BGT) {
+    printGenericArgs(BGT->getGenericArgs());
+  }
+
+  void printGenericArgs(ArrayRef<Type> genericArgs) {
     os << '<';
-    interleave(BGT->getGenericArgs(),
+    interleave(genericArgs,
                [this](Type t) { print(t, None); },
                [this] { os << ", "; });
     os << '>';

lib/PrintAsObjC/ModuleContentsWriter.cpp

@@ -57,7 +57,6 @@ class ReferencedTypeFinder : public TypeDeclFinder {
   Action visitTypeAliasType(TypeAliasType *aliasTy) override {
     if (aliasTy->getDecl()->hasClangNode() &&
         !aliasTy->getDecl()->isCompatibilityAlias()) {
-      assert(!aliasTy->getDecl()->isGeneric());
       Callback(*this, aliasTy->getDecl());
     } else {
       Type(aliasTy->getSinglyDesugaredType()).walk(*this);
@@ -319,8 +318,10 @@ class ModuleWriter {
         } else if (auto PD = dyn_cast<ProtocolDecl>(TD)) {
           forwardDeclare(PD);
         } else if (auto TAD = dyn_cast<TypeAliasDecl>(TD)) {
+          bool imported = false;
           if (TAD->hasClangNode())
-            (void)addImport(TD);
+            imported = addImport(TD);
+          assert((imported || !TAD->isGeneric()) && "referencing non-imported generic typealias?");
         } else if (addImport(TD)) {
           return;
         } else if (auto ED = dyn_cast<EnumDecl>(TD)) {

test/PrintAsObjC/Inputs/custom-modules/CompatibilityAlias.h

@@ -1,5 +1,7 @@
 // This file is meant to be included with modules turned off, compiled against
 // the fake clang-importer-sdk.
 #import <Foundation.h>
+#import <objc_generics.h>
 
 @compatibility_alias StringCheese NSString;
+@compatibility_alias GymClass GenericClass;

test/PrintAsObjC/classes.swift

@@ -820,6 +820,9 @@ public class NonObjCClass { }
   // CHECK-NEXT: - (StringCheese * _Nullable)foo SWIFT_WARN_UNUSED_RESULT;
   @objc func foo() -> StringCheese? { return nil }
 
+  // CHECK-NEXT: - (GymClass<StringCheese *> * _Nullable)foosball SWIFT_WARN_UNUSED_RESULT;
+  @objc func foosball() -> GymClass<StringCheese>? { return nil }
+
   // CHECK-NEXT: - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
 }
 // CHECK-NEXT: @end