[TypeChecker] Extend type inference from default expressions to handle nested generic parameters

Adds support for parameter types like `[T?]` or `[(T, U?)]`,
and relaxes restriction on same-type generic parameters.

A same-type requirement is acceptable if it only includes
in-scope generic parameters and concrete types i.e. `T.X == Int`
if accepted if `T` is referenced only by a parameter default
expression is being applied to.

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -6254,7 +6254,12 @@ ERROR(cannot_default_generic_parameter_inferrable_from_another_parameter, none,
 
 ERROR(cannot_default_generic_parameter_inferrable_through_same_type, none,
       "cannot use default expression for inference of %0 because it "
-      "is inferrable through same-type requirement: %1",
+      "is inferrable through same-type requirement: '%1'",
+      (Type, StringRef))
+
+ERROR(cannot_default_generic_parameter_invalid_requirement, none,
+      "cannot use default expression for inference of %0 because "
+      "requirement '%1' refers to other generic parameters",
       (Type, StringRef))
 
 #define UNDEFINE_DIAGNOSTIC_MACROS

lib/Sema/CSSimplify.cpp

@@ -1632,13 +1632,13 @@ static ConstraintSystem::TypeMatchResult matchCallArguments(
     if (parameterBindings[paramIdx].empty()) {
       auto &ctx = cs.getASTContext();
 
-      if (paramTy->isTypeVariableOrMember() &&
+      if (paramTy->hasTypeVariable() &&
           ctx.TypeCheckerOpts.EnableTypeInferenceFromDefaultArguments) {
         auto *paramList = getParameterList(callee);
         auto defaultExprType = paramList->get(paramIdx)->getTypeOfDefaultExpr();
 
         // A caller side default.
-        if (!defaultExprType)
+        if (!defaultExprType || defaultExprType->hasError())
           continue;
 
         // If this is just a regular default type that works

lib/Sema/TypeCheckConstraints.cpp

@@ -441,6 +441,8 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
       isAutoClosure ? CTP_AutoclosureDefaultParameter : CTP_DefaultParameter,
       paramType, /*isDiscarded=*/false);
 
+  auto paramInterfaceTy = paramType->mapTypeOutOfContext();
+
   {
     // Buffer all of the diagnostics produced by \c typeCheckExpression
     // since in some cases we need to try type-checking again with a
@@ -459,6 +461,11 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
     if (!ctx.TypeCheckerOpts.EnableTypeInferenceFromDefaultArguments)
       return Type();
 
+    // Parameter type doesn't have any generic parameters mentioned
+    // in it, so there is nothing to infer.
+    if (!paramInterfaceTy->hasTypeParameter())
+      return Type();
+
     // Ignore any diagnostics emitted by the original type-check.
     diagnostics.abort();
   }
@@ -475,40 +482,76 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
   // If both of aforementioned conditions are true, let's attempt
   // to open generic parameter and infer the type of this default
   // expression.
-  auto interfaceType = paramType->mapTypeOutOfContext();
-  if (!interfaceType->isTypeParameter())
-    return Type();
+  OpenedTypeMap genericParameters;
+
+  ConstraintSystemOptions options;
+  options |= ConstraintSystemFlags::AllowFixes;
+
+  ConstraintSystem cs(DC, options);
+
+  auto *locator = cs.getConstraintLocator(
+      defaultValue, LocatorPathElt::ContextualType(
+                        defaultExprTarget.getExprContextualTypePurpose()));
 
-  auto containsType = [&](Type type, Type contained) {
-    return type.findIf(
-        [&contained](Type nested) { return nested->isEqual(contained); });
+  auto getCanonicalGenericParamTy = [](GenericTypeParamType *GP) {
+    return cast<GenericTypeParamType>(GP->getCanonicalType());
   };
 
-  // Anchor of this default expression.
+  // Find and open all of the generic parameters used by the parameter
+  // and replace them with type variables.
+  auto contextualTy = paramInterfaceTy.transform([&](Type type) -> Type {
+    assert(!type->is<UnboundGenericType>());
+
+    if (auto *GP = type->getAs<GenericTypeParamType>()) {
+      return cs.openGenericParameter(DC->getParent(), GP, genericParameters,
+                                     locator);
+    }
+    return type;
+  });
+
+  auto containsTypes = [&](Type type, OpenedTypeMap &toFind) {
+    return type.findIf([&](Type nested) {
+      if (auto *GP = nested->getAs<GenericTypeParamType>())
+        return toFind.count(getCanonicalGenericParamTy(GP)) > 0;
+      return false;
+    });
+  };
+
+  auto containsGenericParamsExcluding = [&](Type type,
+                                            OpenedTypeMap &exclusions) -> bool {
+    return type.findIf([&](Type type) {
+      if (auto *GP = type->getAs<GenericTypeParamType>())
+        return !exclusions.count(getCanonicalGenericParamTy(GP));
+      return false;
+    });
+  };
+
+  // Anchor of this default expression i.e. function, subscript
+  // or enum case.
   auto *anchor = cast<ValueDecl>(DC->getParent()->getAsDecl());
 
-  // Check whether generic parameter is only mentioned once in
+  // Check whether generic parameters are only mentioned once in
   // the anchor's signature.
   {
     auto anchorTy = anchor->getInterfaceType()->castTo<GenericFunctionType>();
 
-    // Reject if generic parameter could be inferred from result type.
-    if (containsType(anchorTy->getResult(), interfaceType)) {
+    // Reject if generic parameters could be inferred from result type.
+    if (containsTypes(anchorTy->getResult(), genericParameters)) {
       ctx.Diags.diagnose(
           defaultValue->getLoc(),
           diag::cannot_default_generic_parameter_inferrable_from_result,
-          interfaceType);
+          paramInterfaceTy);
       return Type();
     }
 
-    // Reject if generic parameter is used in multiple different positions
+    // Reject if generic parameters are used in multiple different positions
     // in the parameter list.
 
     llvm::SmallVector<unsigned, 2> affectedParams;
     for (unsigned i : indices(anchorTy->getParams())) {
       const auto &param = anchorTy->getParams()[i];
 
-      if (containsType(param.getPlainType(), interfaceType))
+      if (containsTypes(param.getPlainType(), genericParameters))
         affectedParams.push_back(i);
     }
 
@@ -524,27 +567,14 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
           defaultValue->getLoc(),
           diag::
               cannot_default_generic_parameter_inferrable_from_another_parameter,
-          interfaceType, params.str());
+          paramInterfaceTy, params.str());
       return Type();
     }
   }
 
   auto signature = DC->getGenericSignatureOfContext();
   assert(signature && "generic parameter without signature?");
 
-  ConstraintSystemOptions options;
-  options |= ConstraintSystemFlags::AllowFixes;
-
-  ConstraintSystem cs(DC, options);
-
-  auto *locator = cs.getConstraintLocator(
-      defaultValue, LocatorPathElt::ContextualType(
-                        defaultExprTarget.getExprContextualTypePurpose()));
-
-  // A replacement for generic parameter type to associate any generic
-  // requirements with.
-  auto *contextualTy = cs.createTypeVariable(locator, /*flags=*/0);
-
   auto *requirementBaseLocator = cs.getConstraintLocator(
       locator, LocatorPathElt::OpenedGeneric(signature));
 
@@ -553,76 +583,84 @@ Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,
   // a dependent member type), that means it could be inferred through
   // them e.g. `T: X.Y` or `T == U`.
   {
-    auto isViable = [](Type type) {
-      return !(type->hasTypeParameter() && type->hasDependentMember());
-    };
-
     auto recordRequirement = [&](unsigned index, Requirement requirement,
                                  ConstraintLocator *locator) {
       cs.openGenericRequirement(DC->getParent(), index, requirement,
                                 /*skipSelfProtocolConstraint=*/false, locator,
-                                [](Type type) -> Type { return type; });
+                                [&](Type type) -> Type {
+                                  return cs.openType(type, genericParameters);
+                                });
+    };
+
+    auto diagnoseInvalidRequirement = [&](Requirement requirement) {
+      SmallString<32> reqBuf;
+      llvm::raw_svector_ostream req(reqBuf);
+
+      requirement.print(req, PrintOptions());
+
+      ctx.Diags.diagnose(
+          defaultValue->getLoc(),
+          diag::cannot_default_generic_parameter_invalid_requirement,
+          paramInterfaceTy, req.str());
     };
 
     auto requirements = signature.getRequirements();
     for (unsigned reqIdx = 0; reqIdx != requirements.size(); ++reqIdx) {
       auto &requirement = requirements[reqIdx];
 
       switch (requirement.getKind()) {
-      case RequirementKind::Conformance: {
-        if (!requirement.getFirstType()->isEqual(interfaceType))
-          continue;
-
-        recordRequirement(reqIdx,
-                          {RequirementKind::Conformance, contextualTy,
-                           requirement.getSecondType()},
-                          requirementBaseLocator);
-        break;
-      }
+      case RequirementKind::SameType: {
+        auto lhsTy = requirement.getFirstType();
+        auto rhsTy = requirement.getSecondType();
 
-      case RequirementKind::Superclass: {
-        auto subclassTy = requirement.getFirstType();
-        auto superclassTy = requirement.getSecondType();
+        // Unrelated requirement.
+        if (!containsTypes(lhsTy, genericParameters) &&
+            !containsTypes(rhsTy, genericParameters))
+          continue;
 
-        if (subclassTy->isEqual(interfaceType) && isViable(superclassTy)) {
-          recordRequirement(
-              reqIdx, {RequirementKind::Superclass, contextualTy, superclassTy},
-              requirementBaseLocator);
+        // Allow a subset of generic same-type requirements that only mention
+        // "in scope" generic parameters e.g. `T.X == Int` or `T == U.Z`
+        if (!containsGenericParamsExcluding(lhsTy, genericParameters) &&
+            !containsGenericParamsExcluding(rhsTy, genericParameters)) {
+          recordRequirement(reqIdx, requirement, requirementBaseLocator);
+          continue;
         }
 
-        break;
-      }
-
-      case RequirementKind::SameType: {
-        // If there is a same-type constraint that involves our parameter
-        // type, fail the type-check since the type could be inferred
-        // through other positions.
-        if (containsType(requirement.getFirstType(), interfaceType) ||
-            containsType(requirement.getSecondType(), interfaceType)) {
-          SmallString<32> reqBuf;
-          llvm::raw_svector_ostream req(reqBuf);
-
-          requirement.print(req, PrintOptions());
-
-          ctx.Diags.diagnose(
-              defaultValue->getLoc(),
-              diag::
-                  cannot_default_generic_parameter_inferrable_through_same_type,
-              interfaceType, req.str());
+        // If there is a same-type constraint that involves out of scope
+        // generic parameters mixed with in-scope ones, fail the type-check
+        // since the type could be inferred through other positions.
+        {
+          diagnoseInvalidRequirement(requirement);
           return Type();
         }
-
-        continue;
       }
 
+      case RequirementKind::Conformance:
+      case RequirementKind::Superclass:
       case RequirementKind::Layout:
-        if (!requirement.getFirstType()->isEqual(interfaceType))
+        auto adheringTy = requirement.getFirstType();
+
+        // Unrelated requirement.
+        if (!containsTypes(adheringTy, genericParameters))
           continue;
 
-        recordRequirement(reqIdx,
-                          {RequirementKind::Layout, contextualTy,
-                           requirement.getLayoutConstraint()},
-                          requirementBaseLocator);
+        // If adhering type has a mix or in- and out-of-scope parameters
+        // mentioned we need to diagnose.
+        if (containsGenericParamsExcluding(adheringTy, genericParameters)) {
+          diagnoseInvalidRequirement(requirement);
+          return Type();
+        }
+
+        if (requirement.getKind() == RequirementKind::Superclass) {
+          auto superclassTy = requirement.getSecondType();
+
+          if (containsGenericParamsExcluding(superclassTy, genericParameters)) {
+            diagnoseInvalidRequirement(requirement);
+            return Type();
+          }
+        }
+
+        recordRequirement(reqIdx, requirement, requirementBaseLocator);
         break;
       }
     }

test/Constraints/type_inference_from_default_exprs.swift

@@ -16,7 +16,7 @@ protocol P {
 }
 
 func testInferFromSameType<T, U: P>(_: T = 42, _: [U]) where T == U.X {}
-// expected-error@-1 {{cannot use default expression for inference of 'T' because it is inferrable through same-type requirement: T == U.X}}
+// expected-error@-1 {{cannot use default expression for inference of 'T' because requirement 'T == U.X' refers to other generic parameters}}
 
 func test1<T>(_: T = 42) {} // Ok
 
@@ -60,6 +60,46 @@ extension S {
   }
 }
 
+// In nested positions
+func testNested1<T>(_: [T] = [0, 1.0]) {} // Ok (T == Double)
+func testNested2<T>(_: T? = 42.0) {} // Ok
+func testNested2NoInference<T>(_: T? = nil) {} // Ok (old semantics)
+// expected-note@-1 {{in call to function 'testNested2NoInference'}}
+
+struct D : P {
+  typealias X = B
+}
+
+func testNested3<T: P>(_: T = B()) where T.X == String {}
+func testNested4<T: P>(_: T = B()) where T.X == Int {}
+// expected-error@-1 {{global function 'testNested4' requires the types 'B.X' (aka 'String') and 'Int' be equivalent}}
+// expected-note@-2 {{where 'T.X' = 'B.X' (aka 'String')}}
+
+func testNested5<T: P>(_: [T]? = [D()]) where T.X: P, T.X: AnyObject {}
+
+func testNested5Invalid<T: P>(_: [T]? = [B()]) where T.X: P, T.X: AnyObject {}
+// expected-error@-1 {{global function 'testNested5Invalid' requires that 'B.X' (aka 'String') conform to 'P'}}
+// expected-error@-2 {{global function 'testNested5Invalid' requires that 'B.X' (aka 'String') be a class type}}
+// expected-note@-3 2 {{where 'T.X' = 'B.X' (aka 'String')}}
+// expected-note@-4 {{in call to function 'testNested5Invalid'}}
+
+func testNested6<T: P, U>(_: (a: [T?], b: U) = (a: [D()], b: B())) where T.X == U, T.X: P, U: AnyObject { // Ok
+}
+
+// Generic requirements
+
+class GenClass<T> {}
+
+func testReq1<T, U>(_: T = B(), _: U) where T: GenClass<U> {}
+// expected-error@-1 {{cannot use default expression for inference of 'T' because requirement 'T : GenClass<U>' refers to other generic parameters}}
+
+class E : GenClass<B> {
+}
+
+func testReq2<T, U>(_: (T, U) = (E(), B())) where T: GenClass<U>, U: AnyObject {} // Ok
+
+func testReq3<T: P, U>(_: [T?] = [B()], _: U) where T.X == U {}
+// expected-error@-1 {{cannot use default expression for inference of '[T?]' because requirement 'U == T.X' refers to other generic parameters}}
 
 func main() {
   test1() // Ok
@@ -78,4 +118,15 @@ func main() {
 
   _ = S()[] // Ok
   _ = S()[B()] // Ok
+
+  testNested1() // Ok
+  testNested2() // Ok
+  testNested2NoInference() // expected-error {{generic parameter 'T' could not be inferred}}
+
+  testNested3() // Ok
+  testNested5() // Ok
+  testNested5Invalid() // expected-error {{generic parameter 'T' could not be inferred}}
+  testNested6() // Ok
+
+  testReq2() // Ok
 }