[CSBindings] Infer transitive defaults and add them at finalization

Author: xedin

lib/Sema/CSBindings.cpp

@@ -44,9 +44,6 @@ void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
         return rhs->getAs<TypeVariableType>() == TypeVar;
       });
 
-  if (conversions.empty())
-    return;
-
   for (auto *constraint : conversions) {
     auto *tv =
         cs.simplifyType(constraint->getFirstType())->getAs<TypeVariableType>();
@@ -57,16 +54,19 @@ void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
     if (relatedBindings == inferredBindings.end())
       continue;
 
+    auto &bindings = relatedBindings->getSecond();
+
     // Infer transitive protocol requirements.
-    for (auto *protocol : relatedBindings->getSecond().Protocols) {
-      Protocols.push_back(protocol);
-    }
+    llvm::copy(bindings.Protocols, std::back_inserter(Protocols));
+
+    // Infer transitive defaults.
+    llvm::copy(bindings.Defaults, std::back_inserter(Defaults));
 
     // TODO: We shouldn't need this in the future.
     if (constraint->getKind() != ConstraintKind::Subtype)
       continue;
 
-    for (auto &binding : relatedBindings->getSecond().Bindings) {
+    for (auto &binding : bindings.Bindings) {
       // We need the binding kind for the potential binding to
       // either be Exact or Supertypes in order for it to make sense
       // to add Supertype bindings based on the relationship between
@@ -92,6 +92,27 @@ void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
   }
 }
 
+void ConstraintSystem::PotentialBindings::inferDefaultTypes(
+    ConstraintSystem &cs, llvm::SmallPtrSetImpl<CanType> &existingTypes) {
+  /// Add defaultable constraints.
+  for (auto *constraint : Defaults) {
+    Type type = constraint->getSecondType();
+    if (!existingTypes.insert(type->getCanonicalType()).second)
+      continue;
+
+    if (constraint->getKind() == ConstraintKind::DefaultClosureType) {
+      // If there are no other possible bindings for this closure
+      // let's default it to the type inferred from its parameters/body,
+      // otherwise we should only attempt contextual types as a
+      // top-level closure type.
+      if (!Bindings.empty())
+        continue;
+    }
+
+    addPotentialBinding({type, AllowedBindingKind::Exact, constraint});
+  }
+}
+
 void ConstraintSystem::PotentialBindings::finalize(
     ConstraintSystem &cs,
     const llvm::SmallDenseMap<TypeVariableType *,
@@ -105,6 +126,8 @@ void ConstraintSystem::PotentialBindings::finalize(
 
   inferTransitiveBindings(cs, existingTypes, inferredBindings);
 
+  inferDefaultTypes(cs, existingTypes);
+
   // Adjust optionality of existing bindings based on presence of
   // `ExpressibleByNilLiteral` requirement.
   if (llvm::any_of(Protocols, [](Constraint *constraint) {
@@ -153,6 +176,17 @@ void ConstraintSystem::PotentialBindings::finalize(
 
     addPotentialBinding(PotentialBinding::forHole(cs.getASTContext(), locator));
   }
+
+  // Determine if the bindings only constrain the type variable from above with
+  // an existential type; such a binding is not very helpful because it's
+  // impossible to enumerate the existential type's subtypes.
+  if (!Bindings.empty()) {
+    SubtypeOfExistentialType =
+        llvm::all_of(Bindings, [](const PotentialBinding &binding) {
+          return binding.BindingType->isExistentialType() &&
+                 binding.Kind == AllowedBindingKind::Subtypes;
+        });
+  }
 }
 
 Optional<ConstraintSystem::PotentialBindings>
@@ -516,7 +550,6 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) const {
 
   // Consider each of the constraints related to this type variable.
   llvm::SmallPtrSet<CanType, 4> exactTypes;
-  SmallVector<Constraint *, 2> defaultableConstraints;
   SmallVector<PotentialBinding, 4> literalBindings;
   bool hasNonDependentMemberRelationalConstraints = false;
   bool hasDependentMemberRelationalConstraints = false;
@@ -636,7 +669,7 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) const {
       // Do these in a separate pass.
       if (getFixedTypeRecursive(constraint->getFirstType(), true)
               ->getAs<TypeVariableType>() == typeVar) {
-        defaultableConstraints.push_back(constraint);
+        result.Defaults.push_back(constraint);
         hasNonDependentMemberRelationalConstraints = true;
       }
       break;
@@ -854,34 +887,6 @@ ConstraintSystem::getPotentialBindings(TypeVariableType *typeVar) const {
     }
   }
 
-  /// Add defaultable constraints last.
-  for (auto constraint : defaultableConstraints) {
-    Type type = constraint->getSecondType();
-    if (!exactTypes.insert(type->getCanonicalType()).second)
-      continue;
-
-    if (constraint->getKind() == ConstraintKind::DefaultClosureType) {
-      // If there are no other possible bindings for this closure
-      // let's default it to the type inferred from its parameters/body,
-      // otherwise we should only attempt contextual types as a
-      // top-level closure type.
-      if (!result.Bindings.empty())
-        continue;
-    }
-
-    result.addPotentialBinding({type, AllowedBindingKind::Exact, constraint});
-  }
-
-  // Determine if the bindings only constrain the type variable from above with
-  // an existential type; such a binding is not very helpful because it's
-  // impossible to enumerate the existential type's subtypes.
-  result.SubtypeOfExistentialType =
-      std::all_of(result.Bindings.begin(), result.Bindings.end(),
-                  [](const PotentialBinding &binding) {
-                    return binding.BindingType->isExistentialType() &&
-                           binding.Kind == AllowedBindingKind::Subtypes;
-                  });
-
   // If there were both dependent-member and non-dependent-member relational
   // constraints, consider this "fully bound"; we don't want to touch it.
   if (hasDependentMemberRelationalConstraints) {

lib/Sema/ConstraintSystem.h

@@ -4423,6 +4423,9 @@ class ConstraintSystem {
     /// The set of protocol requirements placed on this type variable.
     llvm::TinyPtrVector<Constraint *> Protocols;
 
+    /// The set of constraints which would be used to infer default types.
+    llvm::TinyPtrVector<Constraint *> Defaults;
+
     /// Whether these bindings should be delayed until the rest of the
     /// constraint system is considered "fully bound".
     bool FullyBound = false;
@@ -4574,6 +4577,11 @@ class ConstraintSystem {
                                   ConstraintSystem::PotentialBindings>
             &inferredBindings);
 
+    /// Infer bindings based on any protocol conformances that have default
+    /// types.
+    void inferDefaultTypes(ConstraintSystem &cs,
+                           llvm::SmallPtrSetImpl<CanType> &existingTypes);
+
     /// Finalize binding computation for this type variable by
     /// inferring bindings from context e.g. transitive bindings.
     void finalize(ConstraintSystem &cs,

test/SILGen/function_conversion.swift

@@ -663,14 +663,14 @@ struct FunctionConversionParameterSubstToOrigReabstractionTest {
   }
 }
 
-// CHECK: sil {{.*}} [ossa] @$sS4SIgggoo_S2Ss11AnyHashableVyps5Error_pIegggrrzo_TR
-// CHECK:  [[TUPLE:%.*]] = apply %4(%2, %3) : $@noescape @callee_guaranteed (@guaranteed String, @guaranteed String) -> (@owned String, @owned String)
-// CHECK:  ([[LHS:%.*]], [[RHS:%.*]]) = destructure_tuple [[TUPLE]]
-// CHECK:  [[ADDR:%.*]] = alloc_stack $String
-// CHECK:  store [[LHS]] to [init] [[ADDR]] : $*String
-// CHECK:  [[CVT:%.*]] = function_ref @$ss21_convertToAnyHashableys0cD0VxSHRzlF : $@convention(thin) <τ_0_0 where τ_0_0 : Hashable> (@in_guaranteed τ_0_0) -> @out AnyHashable
-// CHECK:  apply [[CVT]]<String>(%0, [[ADDR]])
-// CHECK: } // end sil function '$sS4SIgggoo_S2Ss11AnyHashableVyps5Error_pIegggrrzo_TR'
+// CHECK: sil hidden [ossa] @$s19function_conversion9dontCrashyyF
+// CHECK: [[FORCE_CAST:%.*]] = function_ref @$ss15_arrayForceCastySayq_GSayxGr0_lF
+// CHECK-NEXT: [[DOWNCAST_RESULT:%.*]] = apply [[FORCE_CAST]]<(String, String), (AnyHashable, Any)>({{.*}})
+// CHECK-NEXT: [[ADDR:%.*]] = alloc_stack $Array<(AnyHashable, Any)>
+// CHECK-NEXT: store [[DOWNCAST_RESULT]] to [init] [[ADDR]] : $*Array<(AnyHashable, Any)>
+// CHECK-NEXT: // function_ref Dictionary.init<A>(uniqueKeysWithValues:)
+// CHECK-NEXT: [[DICT_INIT:%.*]] = function_ref @$sSD20uniqueKeysWithValuesSDyxq_Gqd__n_tcSTRd__x_q_t7ElementRtd__lufC
+// CHECK-NEXT: apply [[DICT_INIT]]<AnyHashable, Any, [(AnyHashable, Any)]>([[ADDR]], [[TYPE:%.*]])
 
 func dontCrash() {
   let userInfo = ["hello": "world"]