Merge pull request swiftlang#30309 from rjmccall/accessor-subst-function-types

Use pattern substitutions to consistently abstract yields

Author: rjmccall

include/swift/AST/TypeDifferenceVisitor.h

@@ -3838,6 +3838,11 @@ class SILParameterInfo {
     return SILParameterInfo(type, getConvention(), getDifferentiability());
   }
 
+  /// Return a version of this parameter info with the convention replaced.
+  SILParameterInfo getWithConvention(ParameterConvention c) const {
+    return SILParameterInfo(getInterfaceType(), c, getDifferentiability());
+  }
+
   /// Transform this SILParameterInfo by applying the user-provided
   /// function to its type.
   ///
@@ -3853,6 +3858,15 @@ class SILParameterInfo {
                                                   ->getCanonicalType());
   }
 
+  /// Treating this parameter info as a component of the given function
+  /// type, apply any substitutions from the function type to it to
+  /// get a substituted version of it, as you would get from
+  /// SILFunctionType::getUnsubstitutedType.
+  SILParameterInfo getUnsubstituted(SILModule &M,
+                                    const SILFunctionType *fnType) const {
+    return getWithInterfaceType(getArgumentType(M, fnType));
+  }
+
   void profile(llvm::FoldingSetNodeID &id) {
     id.AddPointer(getInterfaceType().getPointer());
     id.AddInteger((unsigned)getConvention());
@@ -3955,6 +3969,11 @@ class SILResultInfo {
     return SILResultInfo(type, getConvention());
   }
 
+  /// Return a version of this result info with the convention replaced.
+  SILResultInfo getWithConvention(ResultConvention c) const {
+    return SILResultInfo(getInterfaceType(), c);
+  }
+
   // Does this result convention require indirect storage? This reflects a
   // SILFunctionType's formal (immutable) conventions, as opposed to the
   // transient SIL conventions that dictate SILValue types.
@@ -3980,6 +3999,15 @@ class SILResultInfo {
                                                   ->getCanonicalType());
   }
 
+  /// Treating this result info as a component of the given function
+  /// type, apply any substitutions from the function type to it to
+  /// get a substituted version of it, as you would get from
+  /// SILFunctionType::getUnsubstitutedType.
+  SILResultInfo getUnsubstituted(SILModule &M,
+                                 const SILFunctionType *fnType) const {
+    return getWithInterfaceType(getReturnValueType(M, fnType));
+  }
+
   void profile(llvm::FoldingSetNodeID &id) {
     id.AddPointer(TypeAndConvention.getOpaqueValue());
   }
@@ -4020,6 +4048,11 @@ class SILYieldInfo : public SILParameterInfo {
     return SILYieldInfo(type, getConvention());
   }
 
+  /// Return a version of this yield info with the convention replaced.
+  SILYieldInfo getWithConvention(YieldConvention c) const {
+    return SILYieldInfo(getInterfaceType(), c);
+  }
+
   template<typename F>
   SILYieldInfo map(const F &fn) const {
     return getWithInterfaceType(fn(getInterfaceType()));
@@ -4029,6 +4062,20 @@ class SILYieldInfo : public SILParameterInfo {
     return getWithInterfaceType(getInterfaceType()->mapTypeOutOfContext()
                                                   ->getCanonicalType());
   }
+
+  CanType getYieldValueType(SILModule &M,
+                            const SILFunctionType *fnType) const {
+    return getArgumentType(M, fnType);
+  }
+
+  /// Treating this yield info as a component of the given function
+  /// type, apply any substitutions from the function type to it to
+  /// get a substituted version of it, as you would get from
+  /// SILFunctionType::getUnsubstitutedType.
+  SILYieldInfo getUnsubstituted(SILModule &M,
+                                const SILFunctionType *fnType) const {
+    return getWithInterfaceType(getYieldValueType(M, fnType));
+  }
 };
 
 /// SILCoroutineKind - What kind of coroutine is this SILFunction?
@@ -4840,6 +4887,17 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
   CanSILFunctionType
   withPatternSubstitutions(SubstitutionMap subs) const;
 
+  /// Create a SILFunctionType with the same structure as this one,
+  /// but replacing the invocation generic signature and pattern
+  /// substitutions.  This type must either be polymorphic or have
+  /// pattern substitutions, and the substitution signature must
+  /// match `getSubstGenericSignature()`.
+  CanSILFunctionType
+  withPatternSpecialization(CanGenericSignature sign,
+                            SubstitutionMap subs,
+                            ProtocolConformanceRef witnessConformance =
+                              ProtocolConformanceRef()) const;
+
   class ABICompatibilityCheckResult {
     friend class SILFunctionType;
 

include/swift/AST/Types.h

@@ -354,6 +354,11 @@ class SILFunction
     return SILFunctionConventions(LoweredType, getModule());
   }
 
+  SILFunctionConventions getConventionsInContext() const {
+    auto fnType = getLoweredFunctionTypeInContext(getTypeExpansionContext());
+    return SILFunctionConventions(fnType, getModule());
+  }
+
   SILProfiler *getProfiler() const { return Profiler; }
 
   SILFunction *getDynamicallyReplacedFunction() const {

include/swift/SIL/SILFunction.h

@@ -380,6 +380,11 @@ class SILType {
   bool hasArchetype() const {
     return getASTType()->hasArchetype();
   }
+
+  /// True if the type involves any opaque archetypes.
+  bool hasOpaqueArchetype() const {
+    return getASTType()->hasOpaqueArchetype();
+  }
 
   /// Returns the ASTContext for the referenced Swift type.
   ASTContext &getASTContext() const {

include/swift/SIL/SILType.h

@@ -1515,6 +1515,9 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     OpArgs.push_back('G');
     break;
   }
+
+  auto outerGenericSig = CurGenericSignature;
+  CurGenericSignature = fn->getSubstGenericSignature();
 
   // Mangle the parameters.
   for (auto param : fn->getParameters()) {
@@ -1542,17 +1545,24 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     OpArgs.push_back(getResultConvention(error.getConvention()));
     appendType(error.getInterfaceType());
   }
+
   if (auto sig = fn->getInvocationGenericSignature()) {
     appendGenericSignature(sig);
+    CurGenericSignature = outerGenericSig;
   }
   if (auto subs = fn->getInvocationSubstitutions()) {
     appendFlatGenericArgs(subs);
     appendRetroactiveConformances(subs, Mod);
   }
   if (auto subs = fn->getPatternSubstitutions()) {
     appendGenericSignature(subs.getGenericSignature());
+    CurGenericSignature =
+      fn->getInvocationGenericSignature()
+        ? fn->getInvocationGenericSignature()
+        : outerGenericSig;
     appendFlatGenericArgs(subs);
     appendRetroactiveConformances(subs, Mod);
+    CurGenericSignature = outerGenericSig;
   }
 
   OpArgs.push_back('_');

lib/AST/ASTMangler.cpp

@@ -4208,10 +4208,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
       sub->Printer << ") -> ";
 
-      unsigned totalResults =
-        T->getNumYields() + T->getNumResults() + unsigned(T->hasErrorResult());
-
-      if (totalResults != 1)
+      bool parenthesizeResults = mustParenthesizeResults(T);
+      if (parenthesizeResults)
         sub->Printer << "(";
 
       first = true;
@@ -4235,7 +4233,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         T->getErrorResult().getInterfaceType().print(sub->Printer, subOptions);
       }
 
-      if (totalResults != 1)
+      if (parenthesizeResults)
         sub->Printer << ")";
     }();
 
@@ -4252,6 +4250,24 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  static bool mustParenthesizeResults(SILFunctionType *T) {
+    // If we don't have exactly one result, we must parenthesize.
+    unsigned totalResults =
+      T->getNumYields() + T->getNumResults() + unsigned(T->hasErrorResult());
+    if (totalResults != 1)
+      return true;
+
+    // If we have substitutions, we must parenthesize if the single
+    // result is a function type.
+    if (!T->hasPatternSubstitutions() && !T->hasInvocationSubstitutions())
+      return false;
+    if (T->getNumResults() == 1)
+      return isa<SILFunctionType>(T->getResults()[0].getInterfaceType());
+    if (T->getNumYields() == 1)
+      return isa<SILFunctionType>(T->getYields()[0].getInterfaceType());
+    return isa<SILFunctionType>(T->getErrorResult().getInterfaceType());
+  }
+
   void visitSILBlockStorageType(SILBlockStorageType *T) {
     Printer << "@block_storage ";
     printWithParensIfNotSimple(T->getCaptureType());

lib/AST/ASTPrinter.cpp

@@ -5267,6 +5267,25 @@ SILFunctionType::withPatternSubstitutions(SubstitutionMap subs) const {
                           getWitnessMethodConformanceOrInvalid());
 }
 
+CanSILFunctionType
+SILFunctionType::withPatternSpecialization(CanGenericSignature sig,
+                                           SubstitutionMap subs,
+                                           ProtocolConformanceRef
+                                             witnessConformance) const {
+  assert(!hasInvocationSubstitutions());
+  subs = subs.getCanonical();
+  assert(!subs || CanGenericSignature(subs.getGenericSignature())
+                    == getSubstGenericSignature());
+  return SILFunctionType::get(sig,
+                          getExtInfo(), getCoroutineKind(),
+                          getCalleeConvention(),
+                          getParameters(), getYields(), getResults(),
+                          getOptionalErrorResult(),
+                          subs, SubstitutionMap(),
+                          const_cast<SILFunctionType*>(this)->getASTContext(),
+                          witnessConformance);
+}
+
 SourceLoc swift::extractNearestSourceLoc(Type ty) {
   if (auto nominal = ty->getAnyNominal())
     return extractNearestSourceLoc(nominal);

lib/AST/Type.cpp

@@ -244,8 +244,18 @@ bool ModuleInterfaceBuilder::collectDepsForSerialization(
 bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     StringRef OutPath, bool ShouldSerializeDeps,
     std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer) {
+
+  auto outerPrettyStackState = llvm::SavePrettyStackState();
+
   bool SubError = false;
   bool RunSuccess = llvm::CrashRecoveryContext().RunSafelyOnThread([&] {
+    // Pretend we're on the original thread for pretty-stack-trace purposes.
+    auto savedInnerPrettyStackState = llvm::SavePrettyStackState();
+    llvm::RestorePrettyStackState(outerPrettyStackState);
+    SWIFT_DEFER {
+      llvm::RestorePrettyStackState(savedInnerPrettyStackState);
+    };
+
     // Note that we don't assume cachePath is the same as the Clang
     // module cache path at this point.
     if (!moduleCachePath.empty())