Merge pull request #41864 from xedin/improvements-for-diagnoseAmbiguity

[ConstraintSystem] Augment `diagnoseAmbiguity` to handle non-expression anchors

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -1746,7 +1746,12 @@ bool TypeChecker::diagnoseSelfAssignment(const Expr *expr) {
 }
 
 bool TrailingClosureAmbiguityFailure::diagnoseAsNote() {
-  auto *anchor = castToExpr(getAnchor());
+  auto *anchor = getAsExpr(getAnchor());
+  // This diagnostic is used opportunistically in `diagnoseAmbiguity`,
+  // which means it cannot assume that anchor is always an expression.
+  if (!anchor)
+    return false;
+
   const auto *expr = findParentExpr(anchor);
   auto *callExpr = dyn_cast_or_null<CallExpr>(expr);
   if (!callExpr)

lib/Sema/ConstraintSystem.cpp

@@ -4557,7 +4557,7 @@ bool ConstraintSystem::diagnoseAmbiguity(ArrayRef<Solution> solutions) {
     auto &overload = diff.overloads[i];
     auto *locator = overload.locator;
 
-    Expr *anchor = nullptr;
+    ASTNode anchor;
 
     // Simplification of member locator would produce a base expression,
     // this is what we want for diagnostics but not for comparisons here
@@ -4567,25 +4567,33 @@ bool ConstraintSystem::diagnoseAmbiguity(ArrayRef<Solution> solutions) {
     // than simplification of `count` would produce `[x]` which is incorrect.
     if (locator->isLastElement<LocatorPathElt::Member>() ||
         locator->isLastElement<LocatorPathElt::ConstructorMember>()) {
-      anchor = getAsExpr(locator->getAnchor());
+      anchor = locator->getAnchor();
     } else {
-      anchor = getAsExpr(simplifyLocatorToAnchor(overload.locator));
+      anchor = simplifyLocatorToAnchor(overload.locator);
     }
 
-    // If we can't resolve the locator to an anchor expression with no path,
+    // If we can't resolve the locator to an anchor with no path,
     // we can't diagnose this well.
     if (!anchor)
       continue;
 
-    auto it = indexMap.find(anchor);
-    if (it == indexMap.end())
-      continue;
-    unsigned index = it->second;
+    // Index and Depth is only applicable to expressions.
+    unsigned index = 0;
+    unsigned depth = 0;
 
-    auto optDepth = getExprDepth(anchor);
-    if (!optDepth)
-      continue;
-    unsigned depth = *optDepth;
+    if (auto *expr = getAsExpr(anchor)) {
+      auto it = indexMap.find(expr);
+      if (it == indexMap.end())
+        continue;
+
+      index = it->second;
+
+      auto optDepth = getExprDepth(expr);
+      if (!optDepth)
+        continue;
+
+      depth = *optDepth;
+    }
 
     // If we don't have a name to hang on to, it'll be hard to diagnose this
     // overload.

test/expr/closure/multi_statement.swift

@@ -234,6 +234,26 @@ func test_local_function_capturing_vars() {
   }
 }
 
+func test_pattern_ambiguity_doesnot_crash_compiler() {
+  enum E {
+  case hello(result: Int) // expected-note 2 {{found this candidate}}
+  case hello(status: Int) // expected-note 2 {{found this candidate}}
+  }
+
+  let _: (E) -> Void = {
+    switch $0 {
+    case .hello(_): break // expected-error {{ambiguous use of 'hello'}}
+    }
+  }
+
+  let _: (E) -> Void = {
+    switch $0 {
+    case let E.hello(x): print(x) // expected-error {{ambiguous use of 'hello'}}
+    default: break
+    }
+  }
+}
+
 func test_taps_type_checked_with_correct_decl_context() {
   struct Path {
     func contains<T>(_: T) -> Bool where T: StringProtocol { return false }