Merge pull request #42004 from AnthonyLatsis/type-witness-system-flagged

TypeWitnessSystem: Disable by default

Author: AnthonyLatsis

include/swift/Basic/LangOptions.h

@@ -352,6 +352,10 @@ namespace swift {
     /// Enable variadic generics.
     bool EnableExperimentalVariadicGenerics = false;
 
+    /// Enable experimental associated type inference using type witness
+    /// systems.
+    bool EnableExperimentalAssociatedTypeInference = false;
+
     /// Disable the implicit import of the _Concurrency module.
     bool DisableImplicitConcurrencyModuleImport =
         !SWIFT_IMPLICIT_CONCURRENCY_IMPORT;

include/swift/Option/FrontendOptions.td

@@ -556,6 +556,10 @@ def enable_experimental_variadic_generics :
   Flag<["-"], "enable-experimental-variadic-generics">,
   HelpText<"Enable experimental support for variadic generic types">;
 
+def enable_experimental_associated_type_inference :
+  Flag<["-"], "enable-experimental-associated-type-inference">,
+  HelpText<"Enable experimental associated type inference via type witness systems">;
+
 def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;

lib/Frontend/CompilerInvocation.cpp

@@ -459,6 +459,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalVariadicGenerics |=
     Args.hasArg(OPT_enable_experimental_variadic_generics);
 
+  Opts.EnableExperimentalAssociatedTypeInference |=
+      Args.hasArg(OPT_enable_experimental_associated_type_inference);
+
   Opts.EnableExperimentalMoveOnly |=
     Args.hasArg(OPT_enable_experimental_move_only);
 

lib/Sema/TypeCheckProtocol.h

@@ -100,6 +100,35 @@ CheckTypeWitnessResult checkTypeWitness(Type type,
                                         const NormalProtocolConformance *Conf,
                                         SubstOptions options = None);
 
+/// A type witness inferred without the aid of a specific potential
+/// value witness.
+class AbstractTypeWitness {
+  AssociatedTypeDecl *AssocType;
+  Type TheType;
+
+  /// The defaulted associated type that was used to infer this type witness.
+  /// Need not necessarilly match \c AssocType, but their names must.
+  AssociatedTypeDecl *DefaultedAssocType;
+
+public:
+  AbstractTypeWitness(AssociatedTypeDecl *AssocType, Type TheType,
+                      AssociatedTypeDecl *DefaultedAssocType = nullptr)
+      : AssocType(AssocType), TheType(TheType),
+        DefaultedAssocType(DefaultedAssocType) {
+    assert(AssocType && TheType);
+    assert(!DefaultedAssocType ||
+           (AssocType->getName() == DefaultedAssocType->getName()));
+  }
+
+  AssociatedTypeDecl *getAssocType() const { return AssocType; }
+
+  Type getType() const { return TheType; }
+
+  AssociatedTypeDecl *getDefaultedAssocType() const {
+    return DefaultedAssocType;
+  }
+};
+
 /// The set of associated types that have been inferred by matching
 /// the given value witness to its corresponding requirement.
 struct InferredAssociatedTypesByWitness {
@@ -916,7 +945,7 @@ class TypeWitnessSystem final {
   struct TypeWitnessCandidate final {
     /// The defaulted associated type declaration correlating with this
     /// candidate, if present.
-    const AssociatedTypeDecl *DefaultedAssocType;
+    AssociatedTypeDecl *DefaultedAssocType;
 
     /// The equivalence class of this candidate.
     EquivalenceClass *EquivClass;
@@ -944,7 +973,7 @@ class TypeWitnessSystem final {
 
   /// Get the defaulted associated type relating to the resolved type witness
   /// for the associated type with the given name, if present.
-  const AssociatedTypeDecl *getDefaultedAssocType(Identifier name) const;
+  AssociatedTypeDecl *getDefaultedAssocType(Identifier name) const;
 
   /// Record a type witness for the given associated type name.
   ///
@@ -958,8 +987,7 @@ class TypeWitnessSystem final {
   /// defines the given default type.
   ///
   /// \note This need not lead to the resolution of a type witness.
-  void addDefaultTypeWitness(Type type,
-                             const AssociatedTypeDecl *defaultedAssocType);
+  void addDefaultTypeWitness(Type type, AssociatedTypeDecl *defaultedAssocType);
 
   /// Record the given same-type requirement, if regarded of interest to
   /// the system.
@@ -1076,16 +1104,24 @@ class AssociatedTypeInference {
     ConformanceChecker &checker,
     const llvm::SetVector<AssociatedTypeDecl *> &assocTypes);
 
+  /// Compute a "fixed" type witness for an associated type, e.g.,
+  /// if the refined protocol requires it to be equivalent to some other type.
+  Type computeFixedTypeWitness(AssociatedTypeDecl *assocType);
+
   /// Compute the default type witness from an associated type default,
   /// if there is one.
-  Optional<std::pair<AssociatedTypeDecl *, Type>>
+  Optional<AbstractTypeWitness>
   computeDefaultTypeWitness(AssociatedTypeDecl *assocType) const;
 
   /// Compute the "derived" type witness for an associated type that is
   /// known to the compiler.
   std::pair<Type, TypeDecl *>
   computeDerivedTypeWitness(AssociatedTypeDecl *assocType);
 
+  /// Compute a type witness without using a specific potential witness.
+  Optional<AbstractTypeWitness>
+  computeAbstractTypeWitness(AssociatedTypeDecl *assocType);
+
   /// Collect abstract type witnesses and feed them to the given system.
   void collectAbstractTypeWitnesses(
       TypeWitnessSystem &system,

lib/Sema/TypeCheckProtocolInference.cpp

@@ -798,7 +798,56 @@ AssociatedTypeDecl *AssociatedTypeInference::findDefaultedAssociatedType(
   return results.size() == 1 ? results.front() : nullptr;
 }
 
-Optional<std::pair<AssociatedTypeDecl *, Type>>
+Type AssociatedTypeInference::computeFixedTypeWitness(
+                                            AssociatedTypeDecl *assocType) {
+  Type resultType;
+
+  // Look at all of the inherited protocols to determine whether they
+  // require a fixed type for this associated type.
+  for (auto conformedProto : adoptee->getAnyNominal()->getAllProtocols()) {
+    if (conformedProto != assocType->getProtocol() &&
+        !conformedProto->inheritsFrom(assocType->getProtocol()))
+      continue;
+
+    auto sig = conformedProto->getGenericSignature();
+
+    // FIXME: The RequirementMachine will assert on re-entrant construction.
+    // We should find a more principled way of breaking this cycle.
+    if (ctx.isRecursivelyConstructingRequirementMachine(sig.getCanonicalSignature()) ||
+        ctx.isRecursivelyConstructingRequirementMachine(conformedProto) ||
+        conformedProto->isComputingRequirementSignature())
+      continue;
+
+    auto selfTy = conformedProto->getSelfInterfaceType();
+    if (!sig->requiresProtocol(selfTy, assocType->getProtocol()))
+      continue;
+
+    auto structuralTy = DependentMemberType::get(selfTy, assocType->getName());
+    const auto ty = sig.getCanonicalTypeInContext(structuralTy);
+
+    // A dependent member type with an identical base and name indicates that
+    // the protocol does not same-type constrain it in any way; move on to
+    // the next protocol.
+    if (auto *const memberTy = ty->getAs<DependentMemberType>()) {
+      if (memberTy->getBase()->isEqual(selfTy) &&
+          memberTy->getName() == assocType->getName())
+        continue;
+    }
+
+    if (!resultType) {
+      resultType = ty;
+      continue;
+    }
+
+    // FIXME: Bailing out on ambiguity.
+    if (!resultType->isEqual(ty))
+      return Type();
+  }
+
+  return resultType;
+}
+
+Optional<AbstractTypeWitness>
 AssociatedTypeInference::computeDefaultTypeWitness(
     AssociatedTypeDecl *assocType) const {
   // Go find a default definition.
@@ -814,7 +863,7 @@ AssociatedTypeInference::computeDefaultTypeWitness(
   if (defaultType->hasError())
     return None;
 
-  return std::make_pair(defaultedAssocType, defaultType);
+  return AbstractTypeWitness(assocType, defaultType, defaultedAssocType);
 }
 
 std::pair<Type, TypeDecl *>
@@ -845,6 +894,29 @@ AssociatedTypeInference::computeDerivedTypeWitness(
   return result;
 }
 
+Optional<AbstractTypeWitness>
+AssociatedTypeInference::computeAbstractTypeWitness(
+    AssociatedTypeDecl *assocType) {
+  // We don't have a type witness for this associated type, so go
+  // looking for more options.
+  if (Type concreteType = computeFixedTypeWitness(assocType))
+    return AbstractTypeWitness(assocType, concreteType);
+
+  // If we can form a default type, do so.
+  if (const auto &typeWitness = computeDefaultTypeWitness(assocType))
+    return typeWitness;
+
+  // If there is a generic parameter of the named type, use that.
+  if (auto genericSig = dc->getGenericSignatureOfContext()) {
+    for (auto gp : genericSig.getInnermostGenericParams()) {
+      if (gp->getName() == assocType->getName())
+        return AbstractTypeWitness(assocType, gp);
+    }
+  }
+
+  return None;
+}
+
 void AssociatedTypeInference::collectAbstractTypeWitnesses(
     TypeWitnessSystem &system,
     ArrayRef<AssociatedTypeDecl *> unresolvedAssocTypes) const {
@@ -878,8 +950,9 @@ void AssociatedTypeInference::collectAbstractTypeWitnesses(
     }
 
     // If we find a default type definition, feed it to the system.
-    if (const auto declAndType = computeDefaultTypeWitness(assocType)) {
-      system.addDefaultTypeWitness(declAndType->second, declAndType->first);
+    if (const auto &typeWitness = computeDefaultTypeWitness(assocType)) {
+      system.addDefaultTypeWitness(typeWitness->getType(),
+                                   typeWitness->getDefaultedAssocType());
     } else {
       // As a last resort, look for a generic parameter that matches the name
       // of the associated type.
@@ -1128,26 +1201,56 @@ AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
     return nullptr;
   }
 
-  TypeWitnessSystem system(unresolvedAssocTypes);
-  collectAbstractTypeWitnesses(system, unresolvedAssocTypes);
+  // Attempt to compute abstract type witnesses for associated types that could
+  // not resolve otherwise.
+  llvm::SmallVector<AbstractTypeWitness, 2> abstractTypeWitnesses;
 
-  if (ctx.LangOpts.DumpTypeWitnessSystems) {
-    system.dump(llvm::dbgs(), conformance);
-  }
+  if (ctx.LangOpts.EnableExperimentalAssociatedTypeInference) {
+    TypeWitnessSystem system(unresolvedAssocTypes);
+    collectAbstractTypeWitnesses(system, unresolvedAssocTypes);
 
-  // If we couldn't resolve an associated type, bail out.
-  for (auto *assocType : unresolvedAssocTypes) {
-    if (!system.hasResolvedTypeWitness(assocType->getName())) {
-      return assocType;
+    if (ctx.LangOpts.DumpTypeWitnessSystems) {
+      system.dump(llvm::dbgs(), conformance);
     }
-  }
 
-  // Record the tentative type witnesses to make them available during
-  // substitutions.
-  for (auto *assocType : unresolvedAssocTypes) {
-    typeWitnesses.insert(
-        assocType,
-        {system.getResolvedTypeWitness(assocType->getName()), reqDepth});
+    // If we couldn't resolve an associated type, bail out.
+    for (auto *assocType : unresolvedAssocTypes) {
+      if (!system.hasResolvedTypeWitness(assocType->getName())) {
+        return assocType;
+      }
+    }
+
+    // Record the tentative type witnesses to make them available during
+    // substitutions.
+    for (auto *assocType : unresolvedAssocTypes) {
+      auto resolvedTy = system.getResolvedTypeWitness(assocType->getName());
+
+      typeWitnesses.insert(assocType, {resolvedTy, reqDepth});
+
+      if (auto *defaultedAssocType =
+              system.getDefaultedAssocType(assocType->getName())) {
+        abstractTypeWitnesses.emplace_back(assocType, resolvedTy,
+                                           defaultedAssocType);
+      } else {
+        abstractTypeWitnesses.emplace_back(assocType, resolvedTy);
+      }
+    }
+  } else {
+    for (auto *const assocType : unresolvedAssocTypes) {
+      // Try to compute the type without the aid of a specific potential
+      // witness.
+      if (const auto &typeWitness = computeAbstractTypeWitness(assocType)) {
+        // Record the type witness immediately to make it available
+        // for substitutions into other tentative type witnesses.
+        typeWitnesses.insert(assocType, {typeWitness->getType(), reqDepth});
+
+        abstractTypeWitnesses.push_back(std::move(typeWitness.getValue()));
+        continue;
+      }
+
+      // The solution is incomplete.
+      return assocType;
+    }
   }
 
   // Check each abstract type witness against the generic requirements on the
@@ -1164,8 +1267,10 @@ AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
   //   associatedtype B: Sequence = Never
   // }
   const auto substOptions = getSubstOptionsWithCurrentTypeWitnesses();
-  for (auto *const assocType : unresolvedAssocTypes) {
-    Type type = system.getResolvedTypeWitness(assocType->getName());
+  for (const auto &witness : abstractTypeWitnesses) {
+    auto *const assocType = witness.getAssocType();
+    Type type = witness.getType();
+
     // Replace type parameters with other known or tentative type witnesses.
     if (type->hasTypeParameter()) {
       // FIXME: We should find a better way to detect and reason about these
@@ -1177,7 +1282,10 @@ AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
       std::function<Type(Type)> substCurrentTypeWitnesses;
       substCurrentTypeWitnesses = [&](Type ty) -> Type {
         if (auto *gp = ty->getAs<GenericTypeParamType>()) {
-          if (isa<ProtocolDecl>(gp->getDecl()->getDeclContext()->getAsDecl())) {
+          // FIXME: 'computeFixedTypeWitness' uses 'getCanonicalTypeInContext',
+          // so if a generic parameter is canonical here, it's 'Self'.
+          if (gp->isCanonical() ||
+              isa<ProtocolDecl>(gp->getDecl()->getDeclContext()->getAsDecl())) {
             return adoptee;
           }
 
@@ -1282,8 +1390,7 @@ AssociatedTypeDecl *AssociatedTypeInference::inferAbstractTypeWitnesses(
             checkTypeWitness(type, assocType, conformance, substOptions)) {
       // We failed to satisfy a requirement. If this is a default type
       // witness failure and we haven't seen one already, write it down.
-      auto *defaultedAssocType =
-          system.getDefaultedAssocType(assocType->getName());
+      auto *defaultedAssocType = witness.getDefaultedAssocType();
       if (defaultedAssocType && !failedDefaultedAssocType &&
           !failed.isError()) {
         failedDefaultedAssocType = defaultedAssocType;
@@ -2187,7 +2294,7 @@ Type TypeWitnessSystem::getResolvedTypeWitness(Identifier name) const {
   return Type();
 }
 
-const AssociatedTypeDecl *
+AssociatedTypeDecl *
 TypeWitnessSystem::getDefaultedAssocType(Identifier name) const {
   assert(this->TypeWitnesses.count(name));
 
@@ -2268,7 +2375,7 @@ void TypeWitnessSystem::addTypeWitness(Identifier name, Type type) {
 }
 
 void TypeWitnessSystem::addDefaultTypeWitness(
-    Type type, const AssociatedTypeDecl *defaultedAssocType) {
+    Type type, AssociatedTypeDecl *defaultedAssocType) {
   const auto name = defaultedAssocType->getName();
   assert(this->TypeWitnesses.count(name));