Merge pull request #5303 from swiftwasm/release/5.8

[pull] swiftwasm-release/5.8 from release/5.8

Author: kateinoigakukun

lib/Sema/CSGen.cpp

@@ -1351,20 +1351,41 @@ namespace {
     Type visitDeclRefExpr(DeclRefExpr *E) {
       auto locator = CS.getConstraintLocator(E);
 
+      auto invalidateReference = [&]() -> Type {
+        auto *hole = CS.createTypeVariable(locator, TVO_CanBindToHole);
+        (void)CS.recordFix(AllowRefToInvalidDecl::create(CS, locator));
+        CS.setType(E, hole);
+        return hole;
+      };
+
       Type knownType;
       if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
         knownType = CS.getTypeIfAvailable(VD);
         if (!knownType)
           knownType = CS.getVarType(VD);
 
         if (knownType) {
+          // An out-of-scope type variable(s) could appear the type of
+          // a declaration only in diagnostic mode when invalid variable
+          // declaration is recursively referenced inside of a multi-statement
+          // closure located somewhere within its initializer e.g.:
+          // `let x = [<call>] { ... print(x) }`. It happens because the
+          // variable assumes the result type of its initializer unless
+          // its specified explicitly.
+          if (isa<ClosureExpr>(CurDC) && knownType->hasTypeVariable()) {
+            if (knownType.findIf([&](Type type) {
+                  auto *typeVar = type->getAs<TypeVariableType>();
+                  if (!typeVar || CS.getFixedType(typeVar))
+                    return false;
+
+                  return !CS.isActiveTypeVariable(typeVar);
+                }))
+              return invalidateReference();
+          }
+
           // If the known type has an error, bail out.
           if (knownType->hasError()) {
-            auto *hole = CS.createTypeVariable(locator, TVO_CanBindToHole);
-            (void)CS.recordFix(AllowRefToInvalidDecl::create(CS, locator));
-            if (!CS.hasType(E))
-              CS.setType(E, hole);
-            return hole;
+            return invalidateReference();
           }
 
           if (!knownType->hasPlaceholder()) {
@@ -1381,10 +1402,7 @@ namespace {
       // (in getTypeOfReference) so we can match non-error param types.
       if (!knownType && E->getDecl()->isInvalid() &&
           !CS.isForCodeCompletion()) {
-        auto *hole = CS.createTypeVariable(locator, TVO_CanBindToHole);
-        (void)CS.recordFix(AllowRefToInvalidDecl::create(CS, locator));
-        CS.setType(E, hole);
-        return hole;
+        return invalidateReference();
       }
 
       // Create an overload choice referencing this declaration and immediately

lib/Sema/CSSyntacticElement.cpp

@@ -64,7 +64,7 @@ class TypeVariableRefFinder : public ASTWalker {
     if (auto *DRE = dyn_cast<DeclRefExpr>(expr)) {
       auto *decl = DRE->getDecl();
 
-      if (auto type = CS.getTypeIfAvailable(DRE->getDecl())) {
+      if (auto type = CS.getTypeIfAvailable(decl)) {
         auto &ctx = CS.getASTContext();
         // If this is not one of the closure parameters which
         // is inferrable from the body, let's replace type

lib/Sema/ConstraintSystem.cpp

@@ -496,6 +496,15 @@ ConstraintLocator *ConstraintSystem::getCalleeLocator(
     }
   }
 
+  {
+    // Pattern match is always a callee regardless of what comes after it.
+    auto iter = path.rbegin();
+    if (locator->findLast<LocatorPathElt::PatternMatch>(iter)) {
+      auto newPath = path.drop_back(iter - path.rbegin());
+      return getConstraintLocator(anchor, newPath);
+    }
+  }
+
   if (locator->findLast<LocatorPathElt::DynamicCallable>()) {
     return getConstraintLocator(anchor, LocatorPathElt::ApplyFunction());
   }

test/Constraints/patterns.swift

@@ -540,3 +540,20 @@ func f60503() {
   let (key, _) = settings.enumerate() // expected-error{{cannot find 'settings' in scope}}
   let (_, _) = settings.enumerate() // expected-error{{cannot find 'settings' in scope}}
 }
+
+// rdar://105089074
+enum EWithIdent<Id> where Id: P { // expected-note 2 {{where 'Id' = 'Int'}}
+case test(Id)
+}
+
+extension [EWithIdent<Int>] {
+  func test() {
+    sorted { lhs, rhs in
+      switch (rhs, rhs) {
+      case let (.test(x), .test(y)): break
+        // expected-error@-1 2 {{generic enum 'EWithIdent' requires that 'Int' conform to 'P'}}
+      case (_, _): break
+      }
+    }
+  }
+}

test/expr/closure/multi_statement.swift

@@ -650,3 +650,46 @@ func test_that_closures_are_attempted_in_order() {
     return false
   }
 }
+
+func test_use_of_concrete_params_in_for_condition() {
+  struct S {
+    var cond: Bool
+  }
+
+  func test(_: (S) -> Void) {}
+
+  test { data in
+    for i in 0...10 where !data.cond { // Ok
+      print(i)
+    }
+  }
+}
+
+// https://github.com/apple/swift/issues/63455
+func test_recursive_var_reference_in_multistatement_closure() {
+  struct MyStruct {
+    func someMethod() {}
+  }
+
+  func takeClosure(_ x: () -> Void) {}
+
+  func test(optionalInt: Int?, themes: MyStruct?) {
+    takeClosure {
+      let int = optionalInt { // expected-error {{cannot call value of non-function type 'Int?'}}
+        print(int)
+      }
+    }
+
+    takeClosure {
+      let theme = themes?.someMethod() { // expected-error {{extra trailing closure passed in call}}
+        _ = theme
+      }
+    }
+
+    takeClosure {
+      let theme = themes?.filter({ $0 }) { // expected-error {{value of type 'MyStruct' has no member 'filter'}}
+        _ = theme
+      }
+    }
+  }
+}

utils/availability-macros.def

@@ -32,7 +32,7 @@ SwiftStdlib 5.4:macOS 11.3, iOS 14.5, watchOS 7.4, tvOS 14.5
 SwiftStdlib 5.5:macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0
 SwiftStdlib 5.6:macOS 12.3, iOS 15.4, watchOS 8.5, tvOS 15.4
 SwiftStdlib 5.7:macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0
-SwiftStdlib 5.8:macOS 9999, iOS 9999, watchOS 9999, tvOS 9999
+SwiftStdlib 5.8:macOS 13.3, iOS 16.4, watchOS 9.4, tvOS 16.4
 
 # Local Variables:
 # mode: conf-unix