Merge pull request #70311 from slavapestov/type-witness-system-inference-stdlib

Get the standard library to build with -enable-experimental-associated-type-inference

Author: slavapestov

include/swift/AST/Types.h

@@ -6761,11 +6761,13 @@ class DependentMemberType : public TypeBase {
   /// Substitute the base type, looking up our associated type in it if it is
   /// non-dependent. Returns null if the member could not be found in the new
   /// base.
-  Type substBaseType(Type base, LookupConformanceFn lookupConformance);
+  Type substBaseType(Type base, LookupConformanceFn lookupConformance,
+                     SubstOptions options);
 
   /// Substitute the root generic type, looking up the chain of associated types.
   /// Returns null if the member could not be found in the new root.
-  Type substRootParam(Type newRoot, LookupConformanceFn lookupConformance);
+  Type substRootParam(Type newRoot, LookupConformanceFn lookupConformance,
+                      SubstOptions options);
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {

include/swift/Basic/Features.def

@@ -151,7 +151,6 @@ EXPERIMENTAL_FEATURE(MoveOnlyTuples, true)
 EXPERIMENTAL_FEATURE(MoveOnlyPartialConsumption, true)
 
 EXPERIMENTAL_FEATURE(OneWayClosureParameters, false)
-EXPERIMENTAL_FEATURE(TypeWitnessSystemInference, false)
 EXPERIMENTAL_FEATURE(LayoutPrespecialization, true)
 
 EXPERIMENTAL_FEATURE(AccessLevelOnImport, true)

include/swift/Basic/LangOptions.h

@@ -585,6 +585,9 @@ namespace swift {
     /// Enable warnings for redundant requirements in generic signatures.
     bool WarnRedundantRequirements = false;
 
+    /// Enable experimental associated type inference improvements.
+    bool EnableExperimentalAssociatedTypeInference = false;
+
     /// Enables dumping type witness systems from associated type inference.
     bool DumpTypeWitnessSystems = false;
 

include/swift/Option/FrontendOptions.td

@@ -654,7 +654,11 @@ def disable_experimental_string_processing :
 
 def enable_experimental_associated_type_inference :
   Flag<["-"], "enable-experimental-associated-type-inference">,
-  HelpText<"Enable experimental associated type inference via type witness systems">;
+  HelpText<"Enable experimental associated type inference improvements">;
+
+def disable_experimental_associated_type_inference :
+  Flag<["-"], "disable-experimental-associated-type-inference">,
+  HelpText<"Disable experimental associated type inference improvements">;
 
 def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,

lib/AST/ASTPrinter.cpp

@@ -3485,10 +3485,6 @@ static bool usesFeatureOneWayClosureParameters(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureTypeWitnessSystemInference(Decl *decl) {
-  return false;
-}
-
 static bool usesFeatureOpaqueTypeErasure(Decl *decl) {
   return false;
 }

lib/AST/ProtocolConformance.cpp

@@ -535,27 +535,48 @@ ProtocolConformance::getAssociatedConformance(Type assocType,
 ProtocolConformanceRef
 NormalProtocolConformance::getAssociatedConformance(Type assocType,
                                                  ProtocolDecl *protocol) const {
+  if (Loader)
+    resolveLazyInfo();
+
   assert(assocType->isTypeParameter() &&
          "associated type must be a type parameter");
 
   llvm::Optional<ProtocolConformanceRef> result;
 
+  auto &ctx = getDeclContext()->getASTContext();
+
   forEachAssociatedConformance(
       [&](Type t, ProtocolDecl *p, unsigned index) {
         if (t->isEqual(assocType) && p == protocol) {
-          // Fill in the signature conformances, if we haven't done so yet.
-          if (!hasComputedAssociatedConformances()) {
-            const_cast<NormalProtocolConformance *>(this)
-                ->finishSignatureConformances();
+          if (!ctx.LangOpts.EnableExperimentalAssociatedTypeInference) {
+            // Fill in the signature conformances, if we haven't done so yet.
+            if (!hasComputedAssociatedConformances()) {
+              const_cast<NormalProtocolConformance *>(this)
+                  ->finishSignatureConformances();
+            }
+          }
+
+          // Not strictly necessary, but avoids a bit of request evaluator
+          // overhead in the happy case.
+          if (hasComputedAssociatedConformances()) {
+            result = AssociatedConformances[index];
+            if (result)
+              return true;
           }
 
-          result = getAssociatedConformance(index);
+          result = evaluateOrDefault(ctx.evaluator,
+                                     AssociatedConformanceRequest{
+                                       const_cast<NormalProtocolConformance *>(this),
+                                       t->getCanonicalType(), p, index
+                                     }, ProtocolConformanceRef::forInvalid());
           return true;
         }
 
         return false;
       });
 
+  assert(result && "Subject type must be exactly equal to left-hand side of a"
+         "conformance requirement in protocol requirement signature");
   return *result;
 }
 

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -346,7 +346,8 @@ static Type substPrefixType(Type type, unsigned suffixLength, Type prefixType,
   auto substBaseType = substPrefixType(memberType->getBase(), suffixLength - 1,
                                        prefixType, sig);
   return memberType->substBaseType(substBaseType,
-                                   LookUpConformanceInSignature(sig.getPointer()));
+                                   LookUpConformanceInSignature(sig.getPointer()),
+                                   llvm::None);
 }
 
 /// Unlike most other queries, the input type can be any type, not just a

lib/AST/Type.cpp

@@ -5580,7 +5580,7 @@ TypeBase::getAutoDiffTangentSpace(LookupConformanceFn lookupConformance) {
 
   // Try to get the `TangentVector` associated type of `base`.
   // Return the associated type if it is valid.
-  auto assocTy = dependentType->substBaseType(this, lookupConformance);
+  auto assocTy = dependentType->substBaseType(this, lookupConformance, llvm::None);
   if (!assocTy->hasError())
     return cache(TangentSpace::getTangentVector(assocTy));
 

lib/AST/TypeSubstitution.cpp

@@ -274,30 +274,32 @@ operator()(CanType dependentType, Type conformingReplacementType,
 }
 
 Type DependentMemberType::substBaseType(ModuleDecl *module, Type substBase) {
-  return substBaseType(substBase, LookUpConformanceInModule(module));
+  return substBaseType(substBase, LookUpConformanceInModule(module), llvm::None);
 }
 
 Type DependentMemberType::substBaseType(Type substBase,
-                                        LookupConformanceFn lookupConformance) {
+                                        LookupConformanceFn lookupConformance,
+                                        SubstOptions options) {
   if (substBase.getPointer() == getBase().getPointer() &&
       substBase->hasTypeParameter())
     return this;
 
-  InFlightSubstitution IFS(nullptr, lookupConformance, llvm::None);
+  InFlightSubstitution IFS(nullptr, lookupConformance, options);
   return getMemberForBaseType(IFS, getBase(), substBase,
                               getAssocType(), getName(),
                               /*level=*/0);
 }
 
 Type DependentMemberType::substRootParam(Type newRoot,
-                                         LookupConformanceFn lookupConformance){
+                                         LookupConformanceFn lookupConformance,
+                                         SubstOptions options) {
   auto base = getBase();
   if (base->is<GenericTypeParamType>()) {
-    return substBaseType(newRoot, lookupConformance);
+    return substBaseType(newRoot, lookupConformance, options);
   }
   if (auto depMem = base->getAs<DependentMemberType>()) {
-    return substBaseType(depMem->substRootParam(newRoot, lookupConformance),
-                         lookupConformance);
+    return substBaseType(depMem->substRootParam(newRoot, lookupConformance, options),
+                         lookupConformance, options);
   }
   return Type();
 }

lib/Frontend/CompilerInvocation.cpp

@@ -910,8 +910,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   }
   if (Args.hasArg(OPT_experimental_one_way_closure_params))
     Opts.Features.insert(Feature::OneWayClosureParameters);
-  if (Args.hasArg(OPT_enable_experimental_associated_type_inference))
-    Opts.Features.insert(Feature::TypeWitnessSystemInference);
   if (Args.hasArg(OPT_enable_experimental_forward_mode_differentiation))
     Opts.Features.insert(Feature::ForwardModeDifferentiation);
   if (Args.hasArg(OPT_enable_experimental_additive_arithmetic_derivation))
@@ -1351,6 +1349,11 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   if (Args.hasArg(OPT_warn_redundant_requirements))
     Opts.WarnRedundantRequirements = true;
 
+  if (Args.hasArg(OPT_enable_experimental_associated_type_inference))
+    Opts.EnableExperimentalAssociatedTypeInference = true;
+  if (Args.hasArg(OPT_disable_experimental_associated_type_inference))
+    Opts.EnableExperimentalAssociatedTypeInference = false;
+
   Opts.DumpTypeWitnessSystems = Args.hasArg(OPT_dump_type_witness_systems);
 
   for (auto &block: FrontendOpts.BlocklistConfigFilePaths)