[CSDiagnostics] Adjust conformance failure diagnostic to check for locatable types

If conformance failure is associated with a `LocatableType`, use
its location to anchor the failure.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -611,6 +611,13 @@ void RequirementFailure::maybeEmitRequirementNote(const Decl *anchor, Type lhs,
                    req.getFirstType(), lhs, req.getSecondType(), rhs);
 }
 
+SourceLoc MissingConformanceFailure::getLoc() const {
+  if (auto *locatable = dyn_cast<LocatableType>(LHS.getPointer())) {
+    return locatable->getLoc();
+  }
+  return RequirementFailure::getLoc();
+}
+
 bool MissingConformanceFailure::diagnoseAsError() {
   auto anchor = getAnchor();
   auto nonConformingType = getLHS();

lib/Sema/CSDiagnostics.h

@@ -259,6 +259,10 @@ class RequirementFailure : public FailureDiagnostic {
         Apply = dyn_cast<ApplyExpr>(parentExpr);
   }
 
+  virtual SourceLoc getLoc() const override {
+    return FailureDiagnostic::getLoc();
+  }
+
   unsigned getRequirementIndex() const {
     auto reqElt =
         getLocator()->castLastElementTo<LocatorPathElt::AnyRequirement>();
@@ -341,6 +345,8 @@ class MissingConformanceFailure final : public RequirementFailure {
 #endif
   }
 
+  virtual SourceLoc getLoc() const override;
+
   bool diagnoseAsError() override;
 
 protected:

test/Constraints/result_builder_diags.swift

@@ -629,15 +629,37 @@ _ = wrapperifyInfer(true) { x in // Ok
 
 struct DoesNotConform {}
 
+struct List<C> {
+  typealias T = C
+
+  init(@TupleBuilder _: () -> C) {}
+}
+
+extension List: P where C: P {}
+
 struct MyView {
-  @TupleBuilder var value: some P { // expected-error {{return type of property 'value' requires that 'DoesNotConform' conform to 'P'}}
+  struct Conforms : P {
+    typealias T = Void
+  }
+
+  @TupleBuilder var value: some P {
+    // expected-note@-1 {{opaque return type declared here}}
+    DoesNotConform() // expected-error {{return type of property 'value' requires that 'DoesNotConform' conform to 'P'}}
+  }
+
+  @TupleBuilder var nestedFailures: some P {
     // expected-note@-1 {{opaque return type declared here}}
-    DoesNotConform()
+    List {
+      List {
+        DoesNotConform()
+        // expected-error@-1 {{return type of property 'nestedFailures' requires that 'DoesNotConform' conform to 'P'}}
+      }
+    }
   }
 
-  @TupleBuilder func test() -> some P { // expected-error {{return type of instance method 'test()' requires that 'DoesNotConform' conform to 'P'}}
+  @TupleBuilder func test() -> some P {
     // expected-note@-1 {{opaque return type declared here}}
-    DoesNotConform()
+    DoesNotConform() // expected-error {{return type of instance method 'test()' requires that 'DoesNotConform' conform to 'P'}}
   }
 
   @TupleBuilder var emptySwitch: some P {

test/Constraints/result_builder_nested_diags.swift

@@ -0,0 +1,95 @@
+// RUN: %target-typecheck-verify-swift -target %target-swift-5.9-abi-triple
+
+protocol Element {
+  associatedtype Body: Element
+
+  @Builder
+  var body: Body { get }
+}
+
+@resultBuilder
+struct Builder {
+  static func buildBlock<C>(_ content: C) -> C {
+    fatalError()
+  }
+
+  static func buildBlock<each C>(
+    _ content: repeat each C
+  ) -> TupleContent<repeat each C> {
+    fatalError()
+  }
+}
+
+struct TupleContent<each Content> {
+  var content: (repeat each Content)
+  var body: Never { fatalError() }
+}
+
+struct List<Content> {
+  @Builder  var content: Content
+
+  var body: Never { fatalError() }
+}
+
+extension List: Element where Content: Element {}
+
+public struct For<Data: RandomAccessCollection, Content> {
+  init(
+    _ data: Data,
+    @Builder content: @escaping (Data.Element) -> Content
+  ) {
+  }
+
+  var body: Never { fatalError() }
+}
+
+extension For: Element where Content: Element {}
+
+extension Never : Element {
+  var body: Never { fatalError() }
+}
+
+extension TupleContent: Element where repeat each Content: Element {}
+
+struct FakeElement {}
+
+struct Element1: Element { var body: some Element { fatalError() } }
+struct Element2: Element { var body: some Element { fatalError() } }
+struct Element3: Element { var body: some Element { fatalError() } }
+
+struct Test1: Element {
+  var body: some Element { // expected-note {{opaque return type declared here}}
+    List {
+      FakeElement()
+      // expected-error@-1 {{return type of property 'body' requires that 'FakeElement' conform to 'Element'}}
+    }
+  }
+}
+
+struct Test2: Element {
+  var body: some Element { // expected-note {{opaque return type declared here}}
+    List {
+      Element1()
+      List {
+        Element2()
+        FakeElement()
+        // expected-error@-1 {{return type of property 'body' requires that 'FakeElement' conform to 'Element'}}
+        Element3()
+      }
+    }
+  }
+}
+
+struct Test3: Element {
+  var body: some Element { // expected-note {{opaque return type declared here}}
+    List {
+      For([1, 2, 3]) { _ in
+        Element1()
+        List {
+          Element2()
+          FakeElement() // expected-error {{return type of property 'body' requires that 'FakeElement' conform to 'Element'}}
+        }
+      }
+    }
+  }
+}

validation-test/compiler_crashers_2_fixed/issue-57241.swift

@@ -8,9 +8,10 @@ struct S {
 
   func test() {
     ForEach(data) { group in
-      ForEach(group) { month in // expected-error {{type '()' cannot conform to 'View'}}
-        // expected-note@-1 {{only concrete types such as structs, enums and classes can conform to protocols}}
+      ForEach(group) { month in
         self.f()
+        // expected-error@-1 {{type '()' cannot conform to 'View'}}
+        // expected-note@-2 {{only concrete types such as structs, enums and classes can conform to protocols}}
       }
     }
   }