[CSGen] Allow _ pattern to be a hole

In cases like `case .test(_)` it might not be possible to
establish a type of `_` and hole cannot be propagated to
it from context if condition of switch is incorrect, so
`_` just like a named pattern should be allowed to become
a hole.

Resolves: rdar://96997534

Author: xedin

lib/Sema/CSGen.cpp

@@ -2290,11 +2290,18 @@ namespace {
         return setType(type);
       }
       case PatternKind::Any: {
-        return setType(
-            externalPatternType
-                ? externalPatternType
-                : CS.createTypeVariable(CS.getConstraintLocator(locator),
-                                        TVO_CanBindToNoEscape));
+        Type type;
+
+        // Always prefer a contextual type when it's available.
+        if (externalPatternType) {
+          type = externalPatternType;
+        } else {
+          type = CS.createTypeVariable(
+              CS.getConstraintLocator(pattern,
+                                      ConstraintLocator::AnyPatternDecl),
+              TVO_CanBindToNoEscape | TVO_CanBindToHole);
+        }
+        return setType(type);
       }
 
       case PatternKind::Named: {

test/Constraints/result_builder_diags.swift

@@ -855,3 +855,40 @@ func test_invalid_result_is_diagnosed() {
     S<Int>()
   }
 }
+
+func test_associated_values_dont_block_solver_when_unresolved() {
+  @resultBuilder
+  struct Builder {
+    static func buildBlock<T>(_ t: T) -> T { t }
+    static func buildEither<T>(first: T) -> T { first }
+    static func buildEither<T>(second: T) -> T { second }
+  }
+
+  struct Value {
+    enum Kind {
+      case a(String)
+      case b
+    }
+
+    var kind: Kind
+  }
+
+  struct Container {
+    var prop: Value? = nil
+  }
+
+  struct TestWithAny {
+    var container: Container
+
+    @Builder var body: String {
+      let v = container.prop.kind // expected-error {{value of optional type 'Value?' must be unwrapped to refer to member 'kind' of wrapped base type 'Value'}}
+      // expected-note@-1 {{chain the optional using '?' to access member 'kind' only for non-'nil' base values}}
+      // expected-note@-2 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
+
+      switch v.kind { // expected-error {{value of type 'Value.Kind' has no member 'kind'}}
+      case .a(_): "a"
+      case .b: "b"
+      }
+    }
+  }
+}