[RequirementMachine] Used loc in sig reqs.

`InferredGenericSignatureRequest` creates `StructuralRequirement`s for
the requirements of the generic signature that is passed to it (if one
is).

Previously, it used invalid `SourceLoc`s for these requirements.  The
result was that when errors that were emitted as a result of those
`StructuralRequirement`s (during concrete type contraction), they would
also have invalid `SourceLoc`s.  The effect was that those errors were
ignored during `diagnoseRequirementErrors`.

Here, use the available loc for those requirements.

rdar://108963047

Author: nate-chandler

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -770,7 +770,7 @@ InferredGenericSignatureRequest::evaluate(
   }();
 
   for (const auto &req : parentSig.getRequirements())
-    requirements.push_back({req, SourceLoc(), /*wasInferred=*/false});
+    requirements.push_back({req, loc, /*wasInferred=*/false});
 
   DeclContext *lookupDC = nullptr;
 

test/Generics/rdar108963047.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol HasElt {
+  associatedtype Element
+}
+struct IntElement : HasElt {
+  typealias Element = Int
+}
+struct FloatElement : HasElt {
+  typealias Element = Float
+}
+
+struct G<T: HasElt> where T.Element == Float {
+  func foo() where T == IntElement {} // expected-error {{generic signature requires types 'IntElement.Element' (aka 'Int') and 'Float' to be the same}}
+}

test/attr/attr_specialize.swift

@@ -10,6 +10,7 @@ extension Int: P {
 
 public protocol ProtocolWithDep {
   associatedtype Element
+  func getElement() -> Element
 }
 
 public class C1 {
@@ -94,7 +95,7 @@ struct FloatElement : HasElt {
   typealias Element = Float
 }
 @_specialize(where T == FloatElement)
-@_specialize(where T == IntElement) // FIXME e/xpected-error{{'T.Element' cannot be equal to both 'IntElement.Element' (aka 'Int') and 'Float'}}
+@_specialize(where T == IntElement) // expected-error{{generic signature requires types 'IntElement.Element' (aka 'Int') and 'Float' to be the same}}
 func sameTypeRequirement<T : HasElt>(_ t: T) where T.Element == Float {}
 
 @_specialize(where T == Sub)
@@ -333,3 +334,26 @@ public func testAvailability3<T>(_ t: T) {}
 // CHECK: public func testAvailability4<T>(_ t: T)
 @_specialize(exported: true, availability: SwiftStdlib 5.1, *; where T == Int)
 public func testAvailability4<T>(_ t: T) {}
+
+public struct ExpectedElement {
+  @inline(never)
+  public func hello() {}
+}
+
+public struct ConformerElement {}
+
+public struct Conformer : ProtocolWithDep {
+  public typealias Element = ConformerElement
+  public func getElement() -> ConformerElement { return ConformerElement() }
+}
+
+@inline(never)
+@_specialize(where T == Conformer) // expected-error{{generic signature requires types 'Conformer.Element' (aka 'ConformerElement') and 'ExpectedElement' to be the same}}
+public func foo<T : ProtocolWithDep>(_ t: T) where T.Element == ExpectedElement {
+  t.getElement().hello()
+}
+
+@_specialize(where T == Conformer) // expected-error{{generic signature requires types 'Conformer.Element' (aka 'ConformerElement') and 'ExpectedElement' to be the same}}
+public func bar<T : ProtocolWithDep>(_ t: T) where T.Element == ExpectedElement {
+  foo(t)
+}