Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

lib/Sema/CSGen.cpp

@@ -2246,7 +2246,7 @@ namespace {
         Type subPatternType = getTypeForPattern(
             subPattern,
             locator.withPathElement(LocatorPathElt::PatternMatch(subPattern)),
-            openedType, bindPatternVarsOneWay);
+            openedType, /*bindPatternVarsOneWay*/false);
 
         if (!subPatternType)
           return Type();

lib/Sema/ConstraintSystem.cpp

@@ -3911,6 +3911,16 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes(
     }
   }
 
+  // If there either no fixes at all or all of the are warnings,
+  // let's diagnose this as regular ambiguity.
+  if (llvm::all_of(solutions, [](const Solution &solution) {
+        return llvm::all_of(solution.Fixes, [](const ConstraintFix *fix) {
+          return fix->isWarning();
+        });
+      })) {
+    return diagnoseAmbiguity(solutions);
+  }
+
   // Algorithm is as follows:
   //
   // a. Aggregate all of the available fixes based on callee locator;

lib/Sema/TypeCheckProtocol.cpp

@@ -1356,6 +1356,27 @@ bool WitnessChecker::findBestWitness(
     }
   }
 
+  // If there are multiple viable matches, drop any that are less available than the
+  // requirement.
+  if (numViable > 1) {
+    SmallVector<RequirementMatch, 2> checkedMatches;
+    bool foundCheckedMatch = false;
+
+    for (auto match : matches) {
+      if (!match.isViable()) {
+        checkedMatches.push_back(match);
+      } else if (checkWitness(requirement, match).Kind != CheckKind::Availability) {
+        foundCheckedMatch = true;
+        checkedMatches.push_back(match);
+      }
+    }
+
+    // If none of the matches were at least as available as the requirement, don't
+    // drop any of them; this will produce better diagnostics.
+    if (foundCheckedMatch)
+      std::swap(checkedMatches, matches);
+  }
+
   if (numViable == 0) {
     // Assume any missing value witnesses for a conformance in a module
     // interface can be treated as opaque.

test/Sema/availability_versions.swift

@@ -1385,7 +1385,7 @@ protocol ProtocolWithRequirementMentioningUnavailable {
 
 protocol HasMethodF {
   associatedtype T
-  func f(_ p: T) // expected-note 4{{protocol requirement here}}
+  func f(_ p: T) // expected-note 3{{protocol requirement here}}
 }
 
 class TriesToConformWithFunctionIntroducedOn10_51 : HasMethodF {
@@ -1499,17 +1499,14 @@ extension TakesClassAvailableOn10_51_B : HasTakesClassAvailableOn10_51 {
 }
 
 
-// We do not want potential unavailability to play a role in picking a witness for a
-// protocol requirement. Rather, the witness should be chosen, regardless of its
-// potential unavailability, and then it should be diagnosed if it is less available
-// than the protocol requires.
-class TestAvailabilityDoesNotAffectWitnessCandidacy : HasMethodF {
-  // Test that we choose the more specialized witness even though it is
-  // less available than the protocol requires and there is a less specialized
-  // witness that has suitable availability.
+// We want conditional availability to play a role in picking a witness for a
+// protocol requirement.
+class TestAvailabilityAffectsWitnessCandidacy : HasMethodF {
+  // Test that we choose the less specialized witness, because the more specialized
+  // witness is conditionally unavailable.
 
   @available(OSX, introduced: 10.51)
-  func f(_ p: Int) { } // expected-error {{protocol 'HasMethodF' requires 'f' to be available in macOS 10.50.0 and newer}}
+  func f(_ p: Int) { }
 
   func f<T>(_ p: T) { }
 }

test/Sema/conformance_availability_disambiguate.swift

@@ -0,0 +1,43 @@
+// RUN: %target-swift-frontend -emit-sil -verify %s | %FileCheck %s
+
+// REQUIRES: OS=macosx
+
+public protocol Potato {
+  func eat()
+}
+
+public protocol Fried {}
+
+extension Potato {
+  public func eat() {}
+}
+
+@available(macOS 100, *)
+extension Potato where Self : Fried {
+  public func eat() {}
+}
+
+// We ought to pick the unconstrained Potato.eat(), not
+// the one from the extension, because the extension has
+// narrower availability than the conformance.
+public struct CurlyFries : Potato, Fried {}
+
+public struct TaterTots {}
+
+// This conformance on the other hand should use the
+// constrained Potato.eat(), since the generic signature
+// is more specific than the unconstrained protocol
+// extension.
+@available(macOS 100, *)
+extension TaterTots : Potato, Fried {}
+
+// We FileCheck the SILGen output to verify that the correct
+// witnesses were chosen above.
+
+// CHECK-LABEL: sil shared [transparent] [thunk] @$s37conformance_availability_disambiguate10CurlyFriesVAA6PotatoA2aDP3eatyyFTW : $@convention(witness_method: Potato) (@in_guaranteed CurlyFries) -> () {
+// CHECK: function_ref @$s37conformance_availability_disambiguate6PotatoPAAE3eatyyF : $@convention(method) <τ_0_0 where τ_0_0 : Potato> (@in_guaranteed τ_0_0) -> ()
+// CHECK: return
+
+// sil shared [transparent] [thunk] @$s37conformance_availability_disambiguate9TaterTotsVAA6PotatoA2aDP3eatyyFTW : $@convention(witness_method: Potato) (@in_guaranteed TaterTots) -> () {
+// CHECK: function_ref @$s37conformance_availability_disambiguate6PotatoPA2A5FriedRzrlE3eatyyF : $@convention(method) <τ_0_0 where τ_0_0 : Fried, τ_0_0 : Potato> (@in_guaranteed τ_0_0) -> ()
+// CHECK: return

test/stdlib/UnsafePointerDiagnostics_warning.swift

@@ -201,10 +201,10 @@ func unsafePointerInitEphemeralConversions() {
   // expected-note@-2 {{use the 'withUnsafeMutableBytes' method on Array in order to explicitly convert argument to buffer pointer valid for a defined scope}}
 
   // FIXME: This is currently ambiguous.
-  _ = OpaquePointer(&foo) // expected-error {{no exact matches in call to initializer}}
+  _ = OpaquePointer(&foo) // expected-error {{ambiguous use of 'init(_:)'}}
 
   // FIXME: This is currently ambiguous.
-  _ = OpaquePointer(&arr) // expected-error {{no exact matches in call to initializer}}
+  _ = OpaquePointer(&arr) // expected-error {{ambiguous use of 'init(_:)'}}
 
   _ = OpaquePointer(arr) // expected-warning {{initialization of 'OpaquePointer' results in a dangling pointer}}
   // expected-note@-1 {{implicit argument conversion from '[Int]' to 'UnsafeRawPointer' produces a pointer valid only for the duration of the call to 'init(_:)'}}

validation-test/Sema/type_checker_crashers_fixed/sr14817.swift

@@ -0,0 +1,25 @@
+// RUN: %target-typecheck-verify-swift
+
+@resultBuilder
+struct MyResultBuilder {
+  static func buildBlock(_ elements: Int...) -> Int { fatalError() }
+}
+
+struct VariableDecl2 {
+  init( // expected-note {{found this candidate}}
+    paramClosure: () -> Int? = { nil },
+    paramInt: Int,
+    @MyResultBuilder paramResultBuilder: () -> Int? = { nil }
+  ) { fatalError() }
+
+  init( // expected-note {{found this candidate}}
+    paramInt: Int,
+    paramClosure: () -> Int? = { nil },
+    @MyResultBuilder paramResultBuilder: () -> Int? = { nil }
+  ) {
+    fatalError()
+  }
+}
+
+let buildable = VariableDecl2(paramInt: 1) { // expected-error {{ambiguous use of 'init'}}
+}

validation-test/Sema/type_checker_crashers_fixed/sr14893.swift

@@ -0,0 +1,29 @@
+// RUN: %target-typecheck-verify-swift -target %target-cpu-apple-macosx10.15 -swift-version 5
+
+// REQUIRES: OS=macosx
+
+enum Category {
+case first
+}
+
+protocol View {}
+
+extension View {
+  func test(_ tag: Category) -> some View {
+    Image()
+  }
+}
+
+@resultBuilder struct ViewBuilder {
+  static func buildBlock<Content>(_ content: Content) -> Content where Content : View { fatalError() }
+}
+
+struct Image : View {
+}
+
+struct MyView {
+  @ViewBuilder var body: some View {
+    let icon: Category! = Category.first // expected-error {{using '!' is not allowed here; perhaps '?' was intended?}} {{23-24=?}}
+    Image().test(icon)
+  }
+}