[IRGen] Fix crashes involving ObjC generic params

Sema allows you to pass type-pinning parameters into an extension of an Objective-C generic class, but IRGen did not properly handle erasing these types to existential types in runtime metadata. This commit corrects that mistake.

Author: beccadax

lib/AST/Type.cpp

@@ -3003,7 +3003,8 @@ Type ArchetypeType::getExistentialType() const {
     constraintTypes.push_back(proto->getDeclaredInterfaceType());
   }
   return ProtocolCompositionType::get(
-     const_cast<ArchetypeType*>(this)->getASTContext(), constraintTypes, false);
+     const_cast<ArchetypeType*>(this)->getASTContext(), constraintTypes,
+                                      requiresClass());
 }
 
 PrimaryArchetypeType::PrimaryArchetypeType(const ASTContext &Ctx,

lib/IRGen/GenProto.cpp

@@ -236,12 +236,17 @@ PolymorphicConvention::PolymorphicConvention(IRGenModule &IGM,
 
 void PolymorphicConvention::addPseudogenericFulfillments() {
   enumerateRequirements([&](GenericRequirement reqt) {
-    MetadataPath path;
-    path.addImpossibleComponent();
+    auto archetype = Generics->getGenericEnvironment()
+                        ->mapTypeIntoContext(reqt.TypeParameter)
+                        ->getAs<ArchetypeType>();
+    assert(archetype && "did not get an archetype by mapping param?");
+    auto erasedTypeParam = archetype->getExistentialType()->getCanonicalType();
+    Sources.emplace_back(MetadataSource::Kind::ErasedTypeMetadata,
+                         reqt.TypeParameter, erasedTypeParam);
 
-    unsigned sourceIndex = 0; // unimportant, since impossible
+    MetadataPath path;
     Fulfillments.addFulfillment({reqt.TypeParameter, reqt.Protocol},
-                                sourceIndex, std::move(path),
+                                Sources.size() - 1, std::move(path),
                                 MetadataState::Complete);
   });
 }
@@ -599,6 +604,17 @@ void EmitPolymorphicParameters::bindExtraSource(
       }
       return;
     }
+
+    case MetadataSource::Kind::ErasedTypeMetadata: {
+      ArtificialLocation Loc(IGF.getDebugScope(), IGF.IGM.DebugInfo.get(),
+                             IGF.Builder);
+      CanType argTy = getTypeInContext(source.Type);
+      llvm::Value *metadata = IGF.emitTypeMetadataRef(source.getFixedType());
+      setTypeMetadataName(IGF.IGM, metadata, argTy);
+      IGF.bindLocalTypeDataFromTypeMetadata(argTy, IsExact, metadata,
+                                            MetadataState::Complete);
+      return;
+    }
   }
   llvm_unreachable("bad source kind!");
 }
@@ -2986,6 +3002,10 @@ namespace {
         case MetadataSource::Kind::SelfMetadata:
         case MetadataSource::Kind::SelfWitnessTable:
           continue;
+
+        // No influence on the arguments.
+        case MetadataSource::Kind::ErasedTypeMetadata:
+          continue;
         }
         llvm_unreachable("bad source kind!");
       }
@@ -3040,6 +3060,10 @@ void EmitPolymorphicArguments::emit(SubstitutionMap subs,
       // Added later.
       continue;
     }
+
+    case MetadataSource::Kind::ErasedTypeMetadata:
+      // No influence on the arguments.
+      continue;
     }
     llvm_unreachable("bad source kind");
   }
@@ -3098,6 +3122,10 @@ NecessaryBindings NecessaryBindings::computeBindings(
     case MetadataSource::Kind::SelfWitnessTable:
       // We'll just pass undef in cases like this.
       continue;
+
+    case MetadataSource::Kind::ErasedTypeMetadata:
+      // Fixed in the body.
+      continue;
     }
     llvm_unreachable("bad source kind");
   }
@@ -3320,6 +3348,8 @@ namespace {
       case MetadataSource::Kind::SelfMetadata:
       case MetadataSource::Kind::SelfWitnessTable:
         return; // handled as a special case in expand()
+      case MetadataSource::Kind::ErasedTypeMetadata:
+        return; // fixed in the body
       }
       llvm_unreachable("bad source kind");
     }

lib/IRGen/GenProto.h

@@ -197,6 +197,11 @@ namespace irgen {
       /// Metadata is derived from the Self witness table parameter
       /// passed via the WitnessMethod convention.
       SelfWitnessTable,
+
+      /// Metadata is obtained directly from the FixedType indicated. Used with
+      /// Objective-C generics, where the actual argument is erased at runtime
+      /// and its existential bound is used instead.
+      ErasedTypeMetadata,
     };
 
     static bool requiresSourceIndex(Kind kind) {
@@ -205,22 +210,31 @@ namespace irgen {
               kind == Kind::GenericLValueMetadata);
     }
 
+    static bool requiresFixedType(Kind kind) {
+      return (kind == Kind::ErasedTypeMetadata);
+    }
+
     enum : unsigned { InvalidSourceIndex = ~0U };
 
   private:
     /// The kind of source this is.
     Kind TheKind;
 
-    /// The parameter index, for ClassPointer and Metadata sources.
-    unsigned Index;
+    /// For ClassPointer, Metadata, and GenericLValueMetadata, the source index;
+    /// for ErasedTypeMetadata, the type; for others, Index should be set to
+    /// InvalidSourceIndex.
+    union {
+      unsigned Index;
+      CanType FixedType;
+    };
 
   public:
     CanType Type;
 
     MetadataSource(Kind kind, CanType type)
       : TheKind(kind), Index(InvalidSourceIndex), Type(type)
     {
-      assert(!requiresSourceIndex(kind));
+      assert(!requiresSourceIndex(kind) && !requiresFixedType(kind));
     }
 
 
@@ -230,12 +244,22 @@ namespace irgen {
       assert(index != InvalidSourceIndex);
     }
 
+    MetadataSource(Kind kind, CanType type, CanType fixedType)
+      : TheKind(kind), FixedType(fixedType), Type(type) {
+      assert(requiresFixedType(kind));
+    }
+
     Kind getKind() const { return TheKind; }
 
     unsigned getParamIndex() const {
       assert(requiresSourceIndex(getKind()));
       return Index;
     }
+
+    CanType getFixedType() const {
+      assert(requiresFixedType(getKind()));
+      return FixedType;
+    }
   };
 
   using GenericParamFulfillmentCallback =

lib/IRGen/GenReflection.cpp

@@ -1118,6 +1118,10 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
       case irgen::MetadataSource::Kind::Metadata:
         Root = SourceBuilder.createMetadataCapture(Source.getParamIndex());
         break;
+
+      case irgen::MetadataSource::Kind::ErasedTypeMetadata:
+        // Fixed in the function body
+        break;
       }
 
       // The metadata might be reached via a non-trivial path (eg,

test/IRGen/Inputs/usr/include/Gizmo.h

@@ -166,3 +166,6 @@ __attribute__((swift_name("OuterType.InnerType")))
 
 @interface ObjcGenericClass<__covariant SectionType>
 @end
+
+@interface FungingArray <Element: id<NSFunging>> : NSObject
+@end

test/IRGen/objc_extensions.swift

@@ -1,7 +1,7 @@
 // RUN: %empty-directory(%t)
 // RUN: %build-irgen-test-overlays
 // RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -disable-objc-attr-requires-foundation-module -emit-module %S/Inputs/objc_extension_base.swift -o %t
-// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -primary-file %s -emit-ir | %FileCheck %s
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -primary-file %s -emit-ir -g | %FileCheck %s
 
 // REQUIRES: CPU=x86_64
 // REQUIRES: objc_interop
@@ -195,3 +195,52 @@ class SwiftSubGizmo : SwiftBaseGizmo {
   }
 }
 
+@inline(never) func opaquePrint(_ value: Any) { print(value) }
+
+/*
+ * Check that we can extend ObjC generics and use both the type and metatype of
+ * the generic parameter. Specifically, we're checking that we emit debug info
+ * if we look up the existential bound, and that we derive the argument to
+ * `opaquePrint(_:)` from the actual parameter, not just the fixed metadata.
+ */
+extension FungingArray {
+  // CHECK-LABEL: define {{.*}} @"$sSo12FungingArrayC15objc_extensionsEyAByxGxcfC"
+  // CHECK-SAME: (%objc_object* %0, %swift.type* swiftself %1)
+  // CHECK: @__swift_instantiateConcreteTypeFromMangledName{{.*}}@"$sSo9NSFunging_XlMD"{{.*}}!dbg
+
+  // CHECK-LABEL: define {{.*}} @"$sSo12FungingArrayC15objc_extensionsEyAByxGxcfc"
+  // CHECK-SAME: (%objc_object* %0, %TSo12FungingArrayC* swiftself %1)
+  // CHECK: [[ALLOCA:%[^, =]+]] = alloca %Any, align 8
+  // CHECK: @__swift_instantiateConcreteTypeFromMangledName{{.*}}@"$sSo9NSFunging_XlMD"{{.*}}!dbg
+  // CHECK: {{%[^, =]+}} = getelementptr inbounds %Any, %Any* [[ALLOCA]], i32 0, i32 0
+  // CHECK: [[ANYBUF:%[^, =]+]] = getelementptr inbounds %Any, %Any* [[ALLOCA]], i32 0, i32 0
+  // CHECK: [[BUFPTR:%[^, =]+]] = {{.*}} [[ANYBUF]]
+  // CHECK: [[BUF_0:%[^, =]+]] = {{.*}} [[BUFPTR]]
+  // CHECK: store {{.*}} %0, {{.*}} [[BUF_0]]
+  // CHECK: call swiftcc void @"$s15objc_extensions11opaquePrintyyypF"(%Any* {{.*}} [[ALLOCA]])
+  @objc public convenience init(_ elem: Element) {
+    opaquePrint(elem)
+    self.init()
+  }
+
+  // CHECK-LABEL: define {{.*}} @"$sSo12FungingArrayC15objc_extensionsE7pinningAByxGxm_tcfC"
+  // CHECK-SAME: (%swift.type* %0, %swift.type* swiftself %1)
+  // CHECK: @__swift_instantiateConcreteTypeFromMangledName{{.*}}@"$sSo9NSFunging_XlMD"{{.*}}!dbg
+
+  // CHECK-LABEL: define {{.*}} @"$sSo12FungingArrayC15objc_extensionsE7pinningAByxGxm_tcfc"
+  // CHECK-SAME: (%swift.type* %0, %TSo12FungingArrayC* swiftself %1)
+  // CHECK: [[ALLOCA:%[^, =]+]] = alloca %Any, align 8
+  // CHECK: @__swift_instantiateConcreteTypeFromMangledName{{.*}}@"$sSo9NSFunging_XlMD"{{.*}}!dbg
+  // CHECK: [[OBJC_CLASS:%[^, =]+]] = call %objc_class* @swift_getObjCClassFromMetadata(%swift.type* %0)
+  // CHECK: [[OBJC_CLASS_OBJ:%[^, =]+]] = bitcast %objc_class* [[OBJC_CLASS]]
+  // CHECK: {{%[^, =]+}} = getelementptr inbounds %Any, %Any* [[ALLOCA]], i32 0, i32 0
+  // CHECK: [[ANYBUF:%[^, =]+]] = getelementptr inbounds %Any, %Any* [[ALLOCA]], i32 0, i32 0
+  // CHECK: [[BUFPTR:%[^, =]+]] = {{.*}} [[ANYBUF]]
+  // CHECK: [[BUF_0:%[^, =]+]] = {{.*}} [[BUFPTR]]
+  // CHECK: store {{.*}} [[OBJC_CLASS_OBJ]], {{.*}} [[BUF_0]]
+  // CHECK: call swiftcc void @"$s15objc_extensions11opaquePrintyyypF"(%Any* {{.*}} [[ALLOCA]])
+  @objc public convenience init(pinning: Element.Type) {
+    opaquePrint(pinning as AnyObject)
+    self.init()
+  }
+}