Merge pull request swiftlang#30496 from DougGregor/contextual-pattern-binding-decl

[Constraint system] Use the PatternBindingDecl context when possible.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7788,7 +7788,9 @@ static Optional<SolutionApplicationTarget> applySolutionToInitialization(
   TypeResolutionOptions options =
       isa<EditorPlaceholderExpr>(initializer->getSemanticsProvidingExpr())
       ? TypeResolverContext::EditorPlaceholderExpr
-      : TypeResolverContext::InExpression;
+      : target.getInitializationPatternBindingDecl()
+        ? TypeResolverContext::PatternBindingDecl
+        : TypeResolverContext::InExpression;
   options |= TypeResolutionFlags::OverrideType;
 
   // Determine the type of the pattern.
@@ -7804,9 +7806,7 @@ static Optional<SolutionApplicationTarget> applySolutionToInitialization(
   finalPatternType = finalPatternType->reconstituteSugar(/*recursive =*/false);
 
   // Apply the solution to the pattern as well.
-  auto contextualPattern =
-      ContextualPattern::forRawPattern(target.getInitializationPattern(),
-                                       target.getDeclContext());
+  auto contextualPattern = target.getInitializationContextualPattern();
   if (auto coercedPattern = TypeChecker::coercePatternToType(
           contextualPattern, finalPatternType, options)) {
     resultTarget.setPattern(coercedPattern);

lib/Sema/CSGen.cpp

@@ -2225,9 +2225,12 @@ namespace {
     /// for the types of each variable declared within the pattern, along
     /// with a one-way constraint binding that to the type to which the
     /// variable will be ascribed or inferred.
-    Type getTypeForPattern(Pattern *pattern, ConstraintLocatorBuilder locator,
-                           Type externalPatternType,
-                           bool bindPatternVarsOneWay) {
+    Type getTypeForPattern(
+       Pattern *pattern, ConstraintLocatorBuilder locator,
+       Type externalPatternType,
+       bool bindPatternVarsOneWay,
+       PatternBindingDecl *patternBinding = nullptr,
+       unsigned patternBindingIndex = 0) {
       // If there's no pattern, then we have an unknown subpattern. Create a
       // type variable.
       if (!pattern) {
@@ -2319,9 +2322,16 @@ namespace {
       case PatternKind::Typed: {
         // FIXME: Need a better locator for a pattern as a base.
         // Compute the type ascribed to the pattern.
-        auto contextualPattern =
-            ContextualPattern::forRawPattern(pattern, CurDC);
+        auto contextualPattern = patternBinding
+            ? ContextualPattern::forPatternBindingDecl(
+                patternBinding, patternBindingIndex)
+            : ContextualPattern::forRawPattern(pattern, CurDC);
+
         Type type = TypeChecker::typeCheckPattern(contextualPattern);
+
+        // Look through reference storage types.
+        type = type->getReferenceStorageReferent();
+
         Type openedType = CS.openUnboundGenericType(type, locator);
 
         // Determine the subpattern type. It will be convertible to the
@@ -4097,7 +4107,9 @@ static bool generateInitPatternConstraints(
   auto locator =
       cs.getConstraintLocator(initializer, LocatorPathElt::ContextualType());
   Type patternType = cs.generateConstraints(
-      pattern, locator, target.shouldBindPatternVarsOneWay());
+      pattern, locator, target.shouldBindPatternVarsOneWay(),
+      target.getInitializationPatternBindingDecl(),
+      target.getInitializationPatternBindingIndex());
   assert(patternType && "All patterns have a type");
 
   if (auto wrappedVar = target.getInitializationWrappedVar()) {
@@ -4199,11 +4211,13 @@ Expr *ConstraintSystem::generateConstraints(Expr *expr, DeclContext *dc) {
   return generateConstraintsFor(*this, expr, dc);
 }
 
-Type ConstraintSystem::generateConstraints(Pattern *pattern,
-                                           ConstraintLocatorBuilder locator,
-                                           bool bindPatternVarsOneWay) {
+Type ConstraintSystem::generateConstraints(
+    Pattern *pattern, ConstraintLocatorBuilder locator,
+    bool bindPatternVarsOneWay, PatternBindingDecl *patternBinding,
+    unsigned patternIndex) {
   ConstraintGenerator cg(*this, nullptr);
-  return cg.getTypeForPattern(pattern, locator, Type(), bindPatternVarsOneWay);
+  return cg.getTypeForPattern(pattern, locator, Type(), bindPatternVarsOneWay,
+                              patternBinding, patternIndex);
 }
 
 bool ConstraintSystem::generateConstraints(StmtCondition condition,
@@ -4276,7 +4290,8 @@ bool ConstraintSystem::generateConstraints(
     // any variables that show up in this pattern, because those variables
     // can be referenced in the guard expressions and the body.
     Type patternType = generateConstraints(
-        pattern, locator, /* bindPatternVarsOneWay=*/true);
+        pattern, locator, /* bindPatternVarsOneWay=*/true,
+        /*patternBinding=*/nullptr, /*patternBindingIndex=*/0);
 
     // Convert the subject type to the pattern, which establishes the
     // bindings.

lib/Sema/ConstraintSystem.cpp

@@ -4160,6 +4160,8 @@ SolutionApplicationTarget::SolutionApplicationTarget(
   expression.wrappedVar = nullptr;
   expression.isDiscarded = isDiscarded;
   expression.bindPatternVarsOneWay = false;
+  expression.patternBinding = nullptr;
+  expression.patternBindingIndex = 0;
 }
 
 void SolutionApplicationTarget::maybeApplyPropertyWrapper() {
@@ -4242,6 +4244,30 @@ SolutionApplicationTarget SolutionApplicationTarget::forInitialization(
   return target;
 }
 
+SolutionApplicationTarget SolutionApplicationTarget::forInitialization(
+    Expr *initializer, DeclContext *dc, Type patternType,
+    PatternBindingDecl *patternBinding, unsigned patternBindingIndex,
+    bool bindPatternVarsOneWay) {
+    auto result = forInitialization(
+        initializer, dc, patternType,
+        patternBinding->getPattern(patternBindingIndex), bindPatternVarsOneWay);
+    result.expression.patternBinding = patternBinding;
+    result.expression.patternBindingIndex = patternBindingIndex;
+    return result;
+}
+
+ContextualPattern
+SolutionApplicationTarget::getInitializationContextualPattern() const {
+  assert(kind == Kind::expression);
+  assert(expression.contextualPurpose == CTP_Initialization);
+  if (expression.patternBinding) {
+    return ContextualPattern::forPatternBindingDecl(
+        expression.patternBinding, expression.patternBindingIndex);
+  }
+
+  return ContextualPattern::forRawPattern(expression.pattern, expression.dc);
+}
+
 bool SolutionApplicationTarget::infersOpaqueReturnType() const {
   assert(kind == Kind::expression);
   switch (expression.contextualPurpose) {

lib/Sema/ConstraintSystem.h

@@ -1206,6 +1206,12 @@ class SolutionApplicationTarget {
       /// Whether to bind the variables encountered within the pattern to
       /// fresh type variables via one-way constraints.
       bool bindPatternVarsOneWay;
+
+      /// The pattern binding declaration for an initialization, if any.
+      PatternBindingDecl *patternBinding;
+
+      /// The index into the pattern binding declaration, if any.
+      unsigned patternBindingIndex;
     } expression;
 
     struct {
@@ -1267,6 +1273,13 @@ class SolutionApplicationTarget {
       Expr *initializer, DeclContext *dc, Type patternType, Pattern *pattern,
       bool bindPatternVarsOneWay);
 
+  /// Form a target for the initialization of a pattern binding entry from
+  /// an expression.
+  static SolutionApplicationTarget forInitialization(
+      Expr *initializer, DeclContext *dc, Type patternType,
+      PatternBindingDecl *patternBinding, unsigned patternBindingIndex,
+      bool bindPatternVarsOneWay);
+
   Expr *getAsExpr() const {
     switch (kind) {
     case Kind::expression:
@@ -1351,6 +1364,9 @@ class SolutionApplicationTarget {
     return expression.pattern;
   }
 
+  /// For a pattern initialization target, retrieve the contextual pattern.
+  ContextualPattern getInitializationContextualPattern() const;
+
   /// Whether this is an initialization for an Optional.Some pattern.
   bool isOptionalSomePatternInit() const {
     return kind == Kind::expression &&
@@ -1374,6 +1390,18 @@ class SolutionApplicationTarget {
     return expression.wrappedVar;
   }
 
+  PatternBindingDecl *getInitializationPatternBindingDecl() const {
+    assert(kind == Kind::expression);
+    assert(expression.contextualPurpose == CTP_Initialization);
+    return expression.patternBinding;
+  }
+
+  unsigned getInitializationPatternBindingIndex() const {
+    assert(kind == Kind::expression);
+    assert(expression.contextualPurpose == CTP_Initialization);
+    return expression.patternBindingIndex;
+  }
+
   /// Whether this context infers an opaque return type.
   bool infersOpaqueReturnType() const;
 
@@ -3398,7 +3426,9 @@ class ConstraintSystem {
   ///
   /// \returns a possibly-sanitized initializer, or null if an error occurred.
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator,
-                           bool bindPatternVarsOneWay);
+                           bool bindPatternVarsOneWay,
+                           PatternBindingDecl *patternBinding,
+                           unsigned patternIndex);
 
   /// Generate constraints for a statement condition.
   ///

lib/Sema/TypeCheckConstraints.cpp

@@ -2352,11 +2352,16 @@ TypeChecker::getTypeOfCompletionOperator(DeclContext *DC, Expr *LHS,
   }
 }
 
-bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
-                                   DeclContext *DC,
-                                   Type patternType) {
-  auto target = SolutionApplicationTarget::forInitialization(
-      initializer, DC, patternType, pattern, /*bindPatternVarsOneWay=*/false);
+bool TypeChecker::typeCheckBinding(
+    Pattern *&pattern, Expr *&initializer, DeclContext *DC,
+    Type patternType, PatternBindingDecl *PBD, unsigned patternNumber) {
+  SolutionApplicationTarget target =
+    PBD ? SolutionApplicationTarget::forInitialization(
+            initializer, DC, patternType, PBD, patternNumber,
+            /*bindPatternVarsOneWay=*/false)
+        : SolutionApplicationTarget::forInitialization(
+            initializer, DC, patternType, pattern,
+            /*bindPatternVarsOneWay=*/false);
 
   // Type-check the initializer.
   bool unresolvedTypeExprs = false;
@@ -2425,7 +2430,8 @@ bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,
     }
   }
 
-  bool hadError = TypeChecker::typeCheckBinding(pattern, init, DC, patternType);
+  bool hadError = TypeChecker::typeCheckBinding(
+      pattern, init, DC, patternType, PBD, patternNumber);
   if (!init) {
     PBD->setInvalid();
     return true;
@@ -2550,7 +2556,8 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       // Collect constraints from the element pattern.
       auto pattern = Stmt->getPattern();
       InitType = cs.generateConstraints(
-          pattern, elementLocator, /*bindPatternVarsOneWay=*/false);
+          pattern, elementLocator, /*bindPatternVarsOneWay=*/false,
+          /*patternBinding=*/nullptr, /*patternBindingIndex=*/0);
       if (!InitType)
         return true;
 

lib/Sema/TypeChecker.h

@@ -916,7 +916,9 @@ void coerceParameterListToType(ParameterList *P, ClosureExpr *CE,
 
 /// Type-check an initialized variable pattern declaration.
 bool typeCheckBinding(Pattern *&P, Expr *&Init, DeclContext *DC,
-                      Type patternType);
+                      Type patternType,
+                      PatternBindingDecl *PBD = nullptr,
+                      unsigned patternNumber = 0);
 bool typeCheckPatternBinding(PatternBindingDecl *PBD, unsigned patternNumber,
                              Type patternType = Type());
 

test/Constraints/iuo.swift

@@ -225,3 +225,7 @@ var y: Int = 2
 
 let r = sr6988(x: x, y: y)
 let _: Int = r
+
+// SR-11998 / rdar://problem/58455441
+class C<T> {}
+var sub: C! = C<Int>()