Merge pull request #71241 from slavapestov/ncgenerics-fixes

Non-copyable generics fixes

Author: slavapestov

include/swift/AST/Decl.h

@@ -5365,10 +5365,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// view of the generic system; see RequirementSignature.h for details.
   RequirementSignature getRequirementSignature() const;
 
-  /// Sometimes we want to make a fake generic signature from the requirements
-  /// of a requirement signature.
-  GenericSignature getRequirementSignatureAsGenericSignature() const;
-
   /// Is the requirement signature currently being computed?
   bool isComputingRequirementSignature() const;
 

include/swift/AST/GenericSignature.h

@@ -310,6 +310,13 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
     return Mem;
   }
 
+  /// Transform the requirements into a form where implicit Copyable and
+  /// Escapable conformances are omitted, and their absence is explicitly
+  /// noted.
+  void getRequirementsWithInverses(
+      SmallVector<Requirement, 2> &reqs,
+      SmallVector<InverseRequirement, 2> &inverses) const;
+
   /// Look up a stored conformance in the generic signature. These are formed
   /// from same-type constraints placed on associated types of generic
   /// parameters which have conformance constraints on them.

include/swift/AST/PrintOptions.h

@@ -329,6 +329,11 @@ struct PrintOptions {
   /// Whether to print generic requirements in a where clause.
   bool PrintGenericRequirements = true;
 
+  /// Whether to print generic signatures with inverse requirements (ie,
+  /// ~Copyable noting the absence of Copyable) or the internal desugared form
+  /// (where the implicit Copyable conformance is spelled explicitly).
+  bool PrintInverseRequirements = false;
+
   /// Whether to print the internal layout name instead of AnyObject, etc.
   bool PrintInternalLayoutName = false;
 

include/swift/AST/RequirementSignature.h

@@ -73,6 +73,16 @@ class RequirementSignature final {
   GenericSignatureErrors getErrors() const {
     return Errors;
   }
+
+  void getRequirementsWithInverses(
+      ProtocolDecl *owner,
+      SmallVector<Requirement, 2> &reqs,
+      SmallVector<InverseRequirement, 2> &inverses) const;
+
+  void print(ProtocolDecl *owner, raw_ostream &OS,
+             const PrintOptions &Options = PrintOptions()) const;
+  void print(ProtocolDecl *owner, ASTPrinter &Printer,
+             const PrintOptions &Opts = PrintOptions()) const;
 };
 
 } // end namespace swift

include/swift/AST/SubstitutionMap.h

@@ -101,26 +101,29 @@ class SubstitutionMap {
   /// Build an empty substitution map.
   SubstitutionMap() { }
 
-  /// Build an interface type substitution map for the given generic
-  /// signature and a vector of Substitutions that correspond to the
-  /// requirements of this generic signature.
+  /// The primitive constructor.
   static SubstitutionMap get(GenericSignature genericSig,
                              ArrayRef<Type> replacementTypes,
                              ArrayRef<ProtocolConformanceRef> conformances) {
     return SubstitutionMap(genericSig, replacementTypes, conformances);
   }
 
-  /// Build an interface type substitution map for the given generic
-  /// signature using the mapping in the given substitutions.
+  /// Translate a substitution map from one generic signature to another
+  /// "compatible" one. Think carefully before using this.
   static SubstitutionMap get(GenericSignature genericSig,
                              SubstitutionMap substitutions);
 
-  /// Build an interface type substitution map for the given generic signature
-  /// from a type substitution function and conformance lookup function.
+  /// General form that takes two callbacks.
   static SubstitutionMap get(GenericSignature genericSig,
                              TypeSubstitutionFn subs,
                              LookupConformanceFn lookupConformance);
 
+  /// Takes an array of replacement types already in the correct form, together
+  /// with a conformance lookup callback.
+  static SubstitutionMap get(GenericSignature genericSig,
+                             ArrayRef<Type> replacementTypes,
+                             LookupConformanceFn lookupConformance);
+
   /// Build a substitution map from the substitutions represented by
   /// the given in-flight substitution.
   ///
@@ -306,6 +309,15 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
   return OS;
 }
 
+/// A function object suitable for use as a \c TypeSubstitutionFn that
+/// queries an array of replacement types.
+struct QueryReplacementTypeArray {
+  GenericSignature sig;
+  ArrayRef<Type> types;
+
+  Type operator()(SubstitutableType *type) const;
+};
+
 /// A function object suitable for use as a \c TypeSubstitutionFn that
 /// queries an underlying \c SubstitutionMap.
 struct QuerySubstitutionMap {

include/swift/AST/TypeCheckRequests.h

@@ -2910,6 +2910,24 @@ class ValueWitnessRequest
   void cacheResult(Witness value) const;
 };
 
+class ResolveValueWitnessesRequest
+    : public SimpleRequest<ResolveValueWitnessesRequest,
+                           evaluator::SideEffect(NormalProtocolConformance *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  evaluator::SideEffect
+  evaluate(Evaluator &evaluator, NormalProtocolConformance *conformance) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class AssociatedConformanceRequest
     : public SimpleRequest<AssociatedConformanceRequest,
                            ProtocolConformanceRef(NormalProtocolConformance *,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -441,6 +441,9 @@ SWIFT_REQUEST(TypeChecker, ResolveTypeWitnessesRequest,
 SWIFT_REQUEST(TypeChecker, ValueWitnessRequest,
               Witness(NormalProtocolConformance *, ValueDecl *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveValueWitnessesRequest,
+              evaluator::SideEffect(NormalProtocolConformance *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PatternTypeRequest,
               Type(ContextualPattern),
               Cached, HasNearestLocation)

include/swift/Basic/LangOptions.h

@@ -793,6 +793,10 @@ namespace swift {
     /// Debug the generic signatures computed by the generic signature builder.
     bool DebugGenericSignatures = false;
 
+    /// If this is set, we skip the inverse transform and print explicit
+    /// Copyable/Escapable requirements in the above.
+    bool DebugInverseRequirements = false;
+
     /// Whether we are debugging the constraint solver.
     ///
     /// This option enables verbose debugging output from the constraint

include/swift/Option/FrontendOptions.td

@@ -440,6 +440,9 @@ def disable_round_trip_debug_types : Flag<["-"], "disable-round-trip-debug-types
 def debug_generic_signatures : Flag<["-"], "debug-generic-signatures">,
   HelpText<"Debug generic signatures">;
 
+def debug_inverse_requirements : Flag<["-"], "debug-inverse-requirements">,
+  HelpText<"Print real requirements in -debug_generic_signatures output">;
+
 def debug_forbid_typecheck_prefix : Separate<["-"], "debug-forbid-typecheck-prefix">,
   HelpText<"Triggers llvm fatal_error if typechecker tries to typecheck a decl "
            "with the provided prefix name">;

lib/AST/ASTDemangler.cpp

@@ -953,7 +953,8 @@ ASTBuilder::createGenericSignature(ArrayRef<BuiltType> builtParams,
 SubstitutionMap
 ASTBuilder::createSubstitutionMap(BuiltGenericSignature sig,
                                   ArrayRef<BuiltType> replacements) {
-  return SubstitutionMap::get(sig, replacements, {});
+  return SubstitutionMap::get(sig, replacements,
+                              LookUpConformanceInSignature(sig.getPointer()));
 }
 
 Type ASTBuilder::subst(Type subject, const BuiltSubstitutionMap &Subs) const {

lib/AST/ASTDumper.cpp

@@ -1192,9 +1192,13 @@ namespace {
       printCommon(PD, "protocol", label);
 
       if (PD->isRequirementSignatureComputed()) {
-        auto requirements = PD->getRequirementSignatureAsGenericSignature();
-        std::string reqSigStr = requirements->getAsString();
-        printFieldQuoted(reqSigStr, "requirement_signature");
+        auto reqSig = PD->getRequirementSignature();
+
+        std::string reqSigStr;
+        llvm::raw_string_ostream out(reqSigStr);
+        reqSig.print(PD, out);
+
+        printFieldQuoted(out.str(), "requirement_signature");
       } else {
         printFlag("uncomputed_requirement_signature");
       }

lib/AST/ASTMangler.cpp

@@ -3005,35 +3005,29 @@ void ASTMangler::appendTypeListElement(Identifier name, Type elementType,
     appendOperator("d");
 }
 
-/// Filters out requirements stating that a type conforms to one of the
-/// invertible protocols.
-/// TODO: reconsituteInverses so the absence of conformances gets mangled
-static void withoutInvertibleRequirements(ArrayRef<Requirement> requirements,
-                                          SmallVector<Requirement, 4> &output) {
-  for (auto req : requirements) {
-    // Skip conformance requirements for invertible protocols.
-    if (req.getKind() == RequirementKind::Conformance
-        && req.getProtocolDecl()->getInvertibleProtocolKind())
-      continue;
-
-    output.push_back(req);
-  }
-}
-
 bool ASTMangler::appendGenericSignature(GenericSignature sig,
                                         GenericSignature contextSig) {
   auto canSig = sig.getCanonicalSignature();
 
+  // FIXME: We just ignore invertible requirements for now.
+  SmallVector<Requirement, 2> reqs;
+  SmallVector<InverseRequirement, 2> inverseReqs;
+  canSig->getRequirementsWithInverses(reqs, inverseReqs);
+
   unsigned initialParamDepth;
   ArrayRef<CanTypeWrapper<GenericTypeParamType>> genericParams;
-  SmallVector<Requirement, 4> requirements;
   if (contextSig) {
     // If the signature is the same as the context signature, there's nothing
     // to do.
     if (contextSig.getCanonicalSignature() == canSig) {
       return false;
     }
 
+    // FIXME: We just ignore invertible requirements for now.
+    SmallVector<Requirement, 2> contextReqs;
+    SmallVector<InverseRequirement, 2> contextInverseReqs;
+    contextSig->getRequirementsWithInverses(contextReqs, contextInverseReqs);
+
     // The signature depth starts above the depth of the context signature.
     if (!contextSig.getGenericParams().empty()) {
       initialParamDepth = contextSig.getGenericParams().back()->getDepth() + 1;
@@ -3053,26 +3047,25 @@ bool ASTMangler::appendGenericSignature(GenericSignature sig,
     // have a special-case mangling for that.
     if (genericParams.empty() &&
         contextSig.getGenericParams().size() == 1 &&
-        contextSig.getRequirements().empty()) {
+        contextReqs.empty()) {
       initialParamDepth = 0;
       genericParams = canSig.getGenericParams();
-      withoutInvertibleRequirements(canSig.getRequirements(), requirements);
     } else {
-      withoutInvertibleRequirements(
-          canSig.requirementsNotSatisfiedBy(contextSig), requirements);
+      llvm::erase_if(reqs, [&](Requirement req) {
+        return contextSig->isRequirementSatisfied(req);
+      });
     }
   } else {
     // Use the complete canonical signature.
     initialParamDepth = 0;
     genericParams = canSig.getGenericParams();
-    withoutInvertibleRequirements(canSig.getRequirements(), requirements);
   }
 
-  if (genericParams.empty() && requirements.empty())
+  if (genericParams.empty() && reqs.empty())
     return false;
 
   appendGenericSignatureParts(sig, genericParams,
-                              initialParamDepth, requirements);
+                              initialParamDepth, reqs);
   return true;
 }