IRGen: Simplify NominalMetadataVisitor's treatment of generic requirements

slavapestov · slavapestov · commit 41aebf8e5ac5 · 2018-08-14T00:20:12.000-07:00
We don't need to substitute the superclass type as we walk up a
class hierarchy, or look up the generic parameters and conformances
to check if they're concrete, since we're always just emitting
null pointers in place of the generic parameters and requirements,
to be filled at runtime.

Also, don't leave space for generic parameters and requirements from
Objective-C superclasses, since that's not how they're represented.
diff --git a/lib/IRGen/ClassMetadataVisitor.h b/lib/IRGen/ClassMetadataVisitor.h
@@ -76,7 +76,7 @@ template <class Impl> class ClassMetadataVisitor
     asImpl().addIVarDestroyer();
 
     // Class members.
-    addClassMembers(Target, Target->getDeclaredTypeInContext());
+    addClassMembers(Target);
   }
 
   /// Notes the beginning of the field offset vector for a particular ancestor
@@ -89,11 +89,13 @@ template <class Impl> class ClassMetadataVisitor
 
 private:
   /// Add fields associated with the given class and its bases.
-  void addClassMembers(ClassDecl *theClass, Type type) {
+  void addClassMembers(ClassDecl *theClass) {
     // Visit the superclass first.
-    if (Type superclass = type->getSuperclass()) {
-      auto *superclassDecl = superclass->getClassOrBoundGenericClass();
-      if (IGM.isResilient(superclassDecl, ResilienceExpansion::Maximal)) {
+    if (auto *superclassDecl = theClass->getSuperclassDecl()) {
+      if (superclassDecl->hasClangNode()) {
+        // Nothing to do; Objective-C classes do not add new members to
+        // Swift class metadata.
+      } else if (IGM.isResilient(superclassDecl, ResilienceExpansion::Maximal)) {
         // Runtime metadata instantiation will initialize our field offset
         // vector and vtable entries.
         //
@@ -104,7 +106,7 @@ template <class Impl> class ClassMetadataVisitor
         // NB: We don't apply superclass substitutions to members because we want
         // consistent metadata layout between generic superclasses and concrete
         // subclasses.
-        addClassMembers(superclassDecl, superclass);
+        addClassMembers(superclassDecl);
       }
     }
 
@@ -114,7 +116,7 @@ template <class Impl> class ClassMetadataVisitor
 
     // Add space for the generic parameters, if applicable.
     // This must always be the first item in the immediate members.
-    asImpl().addGenericFields(theClass, type, theClass);
+    asImpl().addGenericFields(theClass, theClass);
 
     // Add vtable entries.
     asImpl().addVTableEntries(theClass);
@@ -192,13 +194,8 @@ class ClassMetadataScanner : public ClassMetadataVisitor<Impl> {
       addPointer();
     }
   }
-  void addGenericArgument(CanType argument, ClassDecl *forClass) {
-    addPointer();
-  }
-  void addGenericWitnessTable(CanType argument, ProtocolConformanceRef conf,
-                              ClassDecl *forClass) {
-    addPointer();
-  }
+  void addGenericArgument(ClassDecl *forClass) { addPointer(); }
+  void addGenericWitnessTable(ClassDecl *forClass) { addPointer(); }
   void addPlaceholder(MissingMemberDecl *MMD) {
     for (auto i : range(MMD->getNumberOfVTableEntries())) {
       (void)i;
diff --git a/lib/IRGen/EnumMetadataVisitor.h b/lib/IRGen/EnumMetadataVisitor.h
@@ -55,11 +55,11 @@ template <class Impl> class EnumMetadataVisitor
 
     // Generic arguments.
     // This must always be the first piece of trailing data.
-    asImpl().addGenericFields(Target, Target->getDeclaredTypeInContext());
+    asImpl().addGenericFields(Target);
 
     // Reserve a word to cache the payload size if the type has dynamic layout.
     auto &strategy = getEnumImplStrategy(IGM,
-           Target->DeclContext::getDeclaredTypeInContext()->getCanonicalType());
+           Target->getDeclaredTypeInContext()->getCanonicalType());
     if (strategy.needsPayloadSizeInMetadata())
       asImpl().addPayloadSize();
   }
@@ -82,10 +82,8 @@ class EnumMetadataScanner : public EnumMetadataVisitor<Impl> {
   void addMetadataFlags() { addPointer(); }
   void addValueWitnessTable() { addPointer(); }
   void addNominalTypeDescriptor() { addPointer(); }
-  void addGenericArgument(CanType argument) { addPointer(); }
-  void addGenericWitnessTable(CanType argument, ProtocolConformanceRef conf) {
-    addPointer();
-  }
+  void addGenericArgument() { addPointer(); }
+  void addGenericWitnessTable() { addPointer(); }
   void addPayloadSize() { addPointer(); }
   void noteStartOfTypeSpecificMembers() {}
 
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -1929,13 +1929,12 @@ namespace {
     void emitInitializeMethodOverrides(IRGenFunction &IGF,
                                        llvm::Value *metadata) {}
 
-    void addGenericArgument(CanType argTy, ClassDecl *forClass) {
-      B.addNullPointer(IGM.TypeMetadataPtrTy);
+    void addGenericArgument(ClassDecl *forClass) {
+      llvm_unreachable("Fixed class metadata cannot have generic parameters");
     }
 
-    void addGenericWitnessTable(CanType argTy, ProtocolConformanceRef conf,
-                                ClassDecl *forClass) {
-      B.addNullPointer(IGM.WitnessTablePtrTy);
+    void addGenericWitnessTable(ClassDecl *forClass) {
+      llvm_unreachable("Fixed class metadata cannot have generic requirements");
     }
   };
 
@@ -1986,10 +1985,9 @@ namespace {
       }
     }
 
-    void addGenericArgument(CanType argTy, ClassDecl *forClass) {}
+    void addGenericArgument(ClassDecl *forClass) {}
 
-    void addGenericWitnessTable(CanType argTy, ProtocolConformanceRef conf,
-                                ClassDecl *forClass) {}
+    void addGenericWitnessTable(ClassDecl *forClass) {}
   };
 
   /// Base class for laying out class metadata.
@@ -2275,13 +2273,12 @@ namespace {
 
     void addMethodOverride(SILDeclRef baseRef, SILDeclRef declRef) {}
 
-    void addGenericArgument(CanType argTy, ClassDecl *forClass) {
-      Members.addGenericArgument(argTy, forClass);
+    void addGenericArgument(ClassDecl *forClass) {
+      Members.addGenericArgument(forClass);
     }
 
-    void addGenericWitnessTable(CanType argTy, ProtocolConformanceRef conf,
-                                ClassDecl *forClass) {
-      Members.addGenericWitnessTable(argTy, conf, forClass);
+    void addGenericWitnessTable(ClassDecl *forClass) {
+      Members.addGenericWitnessTable(forClass);
     }
 
   protected:
@@ -3036,11 +3033,11 @@ namespace {
       B.addAlignmentPadding(super::IGM.getPointerAlignment());
     }
 
-    void addGenericArgument(CanType type) {
+    void addGenericArgument() {
       B.addNullPointer(IGM.TypeMetadataPtrTy);
     }
 
-    void addGenericWitnessTable(CanType type, ProtocolConformanceRef conf) {
+    void addGenericWitnessTable() {
       B.addNullPointer(IGM.WitnessTablePtrTy);
     }
 
@@ -3287,11 +3284,11 @@ namespace {
       B.add(emitNominalTypeDescriptor());
     }
 
-    void addGenericArgument(CanType type) {
+    void addGenericArgument() {
       B.addNullPointer(IGM.TypeMetadataPtrTy);
     }
 
-    void addGenericWitnessTable(CanType type, ProtocolConformanceRef conf) {
+    void addGenericWitnessTable() {
       B.addNullPointer(IGM.WitnessTablePtrTy);
     }
 
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -3004,8 +3004,7 @@ NecessaryBindings::forFunctionInvocations(IRGenModule &IGM,
 }
 
 /// The information we need to record in generic type metadata
-/// is the information in the type's generic signature, minus the
-/// information recoverable from the type's parent type.  This is
+/// is the information in the type's generic signature.  This is
 /// simply the information that would be passed to a generic function
 /// that takes the (thick) parent metatype as an argument.
 GenericTypeRequirements::GenericTypeRequirements(IRGenModule &IGM,
diff --git a/lib/IRGen/MetadataLayout.cpp b/lib/IRGen/MetadataLayout.cpp
@@ -313,19 +313,18 @@ ClassMetadataLayout::ClassMetadataLayout(IRGenModule &IGM, ClassDecl *decl)
       super::noteStartOfGenericRequirements(forClass);
     }
 
-    void addGenericWitnessTable(CanType argType, ProtocolConformanceRef conf,
-                                ClassDecl *forClass) {
+    void addGenericWitnessTable(ClassDecl *forClass) {
       if (forClass == Target) {
         Layout.NumImmediateMembers++;
       }
-      super::addGenericWitnessTable(argType, conf, forClass);
+      super::addGenericWitnessTable(forClass);
     }
 
-    void addGenericArgument(CanType argType, ClassDecl *forClass) {
+    void addGenericArgument(ClassDecl *forClass) {
       if (forClass == Target) {
         Layout.NumImmediateMembers++;
       }
-      super::addGenericArgument(argType, forClass);
+      super::addGenericArgument(forClass);
     }
 
     void addMethod(SILDeclRef fn) {
diff --git a/lib/IRGen/NominalMetadataVisitor.h b/lib/IRGen/NominalMetadataVisitor.h
@@ -56,28 +56,21 @@ template <class Impl> class NominalMetadataVisitor {
   /// fields.  e.g., if B<T> extends A<T>, the witness for T in A's
   /// section should be enough.
   template <class... T>
-  void addGenericFields(NominalTypeDecl *typeDecl, Type type,
-                        T &&...args) {
+  void addGenericFields(NominalTypeDecl *typeDecl, T &&...args) {
     // The archetype order here needs to be consistent with
     // NominalTypeDescriptorBase::addGenericParams.
     
     // Note that we intentionally don't std::forward 'args'.
     asImpl().noteStartOfGenericRequirements(args...);
 
     GenericTypeRequirements requirements(IGM, typeDecl);
-    if (requirements.empty()) return;
-
-    auto subs = type->getContextSubstitutionMap(IGM.getSwiftModule(),
-                                                typeDecl);
-    requirements.enumerateFulfillments(IGM, subs,
-                    [&](unsigned reqtIndex, CanType argType,
-                        Optional<ProtocolConformanceRef> conf) {
-      if (conf) {
-        asImpl().addGenericWitnessTable(argType, *conf, args...);
+    for (auto reqt : requirements.getRequirements()) {
+      if (reqt.Protocol) {
+        asImpl().addGenericWitnessTable(args...);
       } else {
-        asImpl().addGenericArgument(argType, args...);
+        asImpl().addGenericArgument(args...);
       }
-    });
+    }
 
     asImpl().noteEndOfGenericRequirements(args...);
   }
diff --git a/lib/IRGen/StructMetadataVisitor.h b/lib/IRGen/StructMetadataVisitor.h
@@ -53,7 +53,7 @@ template <class Impl> class StructMetadataVisitor
 
     // Generic arguments.
     // This must always be the first piece of trailing data.
-    asImpl().addGenericFields(Target, Target->getDeclaredTypeInContext());
+    asImpl().addGenericFields(Target);
 
     // Struct field offsets.
     asImpl().noteStartOfFieldOffsets();
@@ -87,10 +87,8 @@ class StructMetadataScanner : public StructMetadataVisitor<Impl> {
   void addValueWitnessTable() { addPointer(); }
   void addNominalTypeDescriptor() { addPointer(); }
   void addFieldOffset(VarDecl *) { addInt32(); }
-  void addGenericArgument(CanType argument) { addPointer(); }
-  void addGenericWitnessTable(CanType argument, ProtocolConformanceRef conf) {
-    addPointer();
-  }
+  void addGenericArgument() { addPointer(); }
+  void addGenericWitnessTable() { addPointer(); }
   void noteStartOfTypeSpecificMembers() {}
 
   void noteEndOfFieldOffsets() {

Original file line number	Diff line number	Diff line change
`@@ -1929,13 +1929,12 @@ namespace {`
`1929`	`1929`	`void emitInitializeMethodOverrides(IRGenFunction &IGF,`
`1930`	`1930`	`llvm::Value *metadata) {}`
`1931`	`1931`
`1932`		`- void addGenericArgument(CanType argTy, ClassDecl *forClass) {`
`1933`		`- B.addNullPointer(IGM.TypeMetadataPtrTy);`
	`1932`	`+ void addGenericArgument(ClassDecl *forClass) {`
	`1933`	`+ llvm_unreachable("Fixed class metadata cannot have generic parameters");`
`1934`	`1934`	`}`
`1935`	`1935`
`1936`		`- void addGenericWitnessTable(CanType argTy, ProtocolConformanceRef conf,`
`1937`		`- ClassDecl *forClass) {`
`1938`		`- B.addNullPointer(IGM.WitnessTablePtrTy);`
	`1936`	`+ void addGenericWitnessTable(ClassDecl *forClass) {`
	`1937`	`+ llvm_unreachable("Fixed class metadata cannot have generic requirements");`
`1939`	`1938`	`}`
`1940`	`1939`	`};`
`1941`	`1940`
`@@ -1986,10 +1985,9 @@ namespace {`
`1986`	`1985`	`}`
`1987`	`1986`	`}`
`1988`	`1987`
`1989`		`- void addGenericArgument(CanType argTy, ClassDecl *forClass) {}`
	`1988`	`+ void addGenericArgument(ClassDecl *forClass) {}`
`1990`	`1989`
`1991`		`- void addGenericWitnessTable(CanType argTy, ProtocolConformanceRef conf,`
`1992`		`- ClassDecl *forClass) {}`
	`1990`	`+ void addGenericWitnessTable(ClassDecl *forClass) {}`
`1993`	`1991`	`};`
`1994`	`1992`
`1995`	`1993`	`/// Base class for laying out class metadata.`
`@@ -2275,13 +2273,12 @@ namespace {`
`2275`	`2273`
`2276`	`2274`	`void addMethodOverride(SILDeclRef baseRef, SILDeclRef declRef) {}`
`2277`	`2275`
`2278`		`- void addGenericArgument(CanType argTy, ClassDecl *forClass) {`
`2279`		`- Members.addGenericArgument(argTy, forClass);`
	`2276`	`+ void addGenericArgument(ClassDecl *forClass) {`
	`2277`	`+ Members.addGenericArgument(forClass);`
`2280`	`2278`	`}`
`2281`	`2279`
`2282`		`- void addGenericWitnessTable(CanType argTy, ProtocolConformanceRef conf,`
`2283`		`- ClassDecl *forClass) {`
`2284`		`- Members.addGenericWitnessTable(argTy, conf, forClass);`
	`2280`	`+ void addGenericWitnessTable(ClassDecl *forClass) {`
	`2281`	`+ Members.addGenericWitnessTable(forClass);`
`2285`	`2282`	`}`
`2286`	`2283`
`2287`	`2284`	`protected:`
`@@ -3036,11 +3033,11 @@ namespace {`
`3036`	`3033`	`B.addAlignmentPadding(super::IGM.getPointerAlignment());`
`3037`	`3034`	`}`
`3038`	`3035`
`3039`		`- void addGenericArgument(CanType type) {`
	`3036`	`+ void addGenericArgument() {`
`3040`	`3037`	`B.addNullPointer(IGM.TypeMetadataPtrTy);`
`3041`	`3038`	`}`
`3042`	`3039`
`3043`		`- void addGenericWitnessTable(CanType type, ProtocolConformanceRef conf) {`
	`3040`	`+ void addGenericWitnessTable() {`
`3044`	`3041`	`B.addNullPointer(IGM.WitnessTablePtrTy);`
`3045`	`3042`	`}`
`3046`	`3043`
`@@ -3287,11 +3284,11 @@ namespace {`
`3287`	`3284`	`B.add(emitNominalTypeDescriptor());`
`3288`	`3285`	`}`
`3289`	`3286`
`3290`		`- void addGenericArgument(CanType type) {`
	`3287`	`+ void addGenericArgument() {`
`3291`	`3288`	`B.addNullPointer(IGM.TypeMetadataPtrTy);`
`3292`	`3289`	`}`
`3293`	`3290`
`3294`		`- void addGenericWitnessTable(CanType type, ProtocolConformanceRef conf) {`
	`3291`	`+ void addGenericWitnessTable() {`
`3295`	`3292`	`B.addNullPointer(IGM.WitnessTablePtrTy);`
`3296`	`3293`	`}`
`3297`	`3294`
Original file line number	Diff line number	Diff line change
`@@ -3004,8 +3004,7 @@ NecessaryBindings::forFunctionInvocations(IRGenModule &IGM,`
`3004`	`3004`	`}`
`3005`	`3005`
`3006`	`3006`	`/// The information we need to record in generic type metadata`
`3007`		`-/// is the information in the type's generic signature, minus the`
`3008`		`-/// information recoverable from the type's parent type. This is`
	`3007`	`+/// is the information in the type's generic signature. This is`
`3009`	`3008`	`/// simply the information that would be passed to a generic function`
`3010`	`3009`	`/// that takes the (thick) parent metatype as an argument.`
`3011`	`3010`	`GenericTypeRequirements::GenericTypeRequirements(IRGenModule &IGM,`
Original file line number	Diff line number	Diff line change
`@@ -313,19 +313,18 @@ ClassMetadataLayout::ClassMetadataLayout(IRGenModule &IGM, ClassDecl *decl)`
`313`	`313`	`super::noteStartOfGenericRequirements(forClass);`
`314`	`314`	`}`
`315`	`315`
`316`		`- void addGenericWitnessTable(CanType argType, ProtocolConformanceRef conf,`
`317`		`- ClassDecl *forClass) {`
	`316`	`+ void addGenericWitnessTable(ClassDecl *forClass) {`
`318`	`317`	`if (forClass == Target) {`
`319`	`318`	`Layout.NumImmediateMembers++;`
`320`	`319`	`}`
`321`		`- super::addGenericWitnessTable(argType, conf, forClass);`
	`320`	`+ super::addGenericWitnessTable(forClass);`
`322`	`321`	`}`
`323`	`322`
`324`		`- void addGenericArgument(CanType argType, ClassDecl *forClass) {`
	`323`	`+ void addGenericArgument(ClassDecl *forClass) {`
`325`	`324`	`if (forClass == Target) {`
`326`	`325`	`Layout.NumImmediateMembers++;`
`327`	`326`	`}`
`328`		`- super::addGenericArgument(argType, forClass);`
	`327`	`+ super::addGenericArgument(forClass);`
`329`	`328`	`}`
`330`	`329`
`331`	`330`	`void addMethod(SILDeclRef fn) {`