RequirementMachine: Fix for FunctionType canonicalization subtlety

We assumed that replacing a subcomponent of a CanType with another
CanType always produces a CanType. This is no longer true because
() throws(Never) -> () canonicalizes down to () -> ().

Author: slavapestov

lib/AST/RequirementMachine/TypeDifference.cpp

@@ -348,13 +348,13 @@ swift::rewriting::buildTypeDifference(
   auto resultSymbol = [&]() {
     switch (symbol.getKind()) {
     case Symbol::Kind::Superclass:
-      return Symbol::forSuperclass(CanType(resultType),
+      return Symbol::forSuperclass(resultType->getCanonicalType(),
                                    resultSubstitutions, ctx);
     case Symbol::Kind::ConcreteType:
-      return Symbol::forConcreteType(CanType(resultType),
+      return Symbol::forConcreteType(resultType->getCanonicalType(),
                                      resultSubstitutions, ctx);
     case Symbol::Kind::ConcreteConformance:
-      return Symbol::forConcreteConformance(CanType(resultType),
+      return Symbol::forConcreteConformance(resultType->getCanonicalType(),
                                             resultSubstitutions,
                                             symbol.getProtocol(),
                                             ctx);

test/Generics/typed_throws.swift

@@ -0,0 +1,26 @@
+// RUN: %target-typecheck-verify-swift -debug-generic-signatures -enable-experimental-feature TypedThrows 2>&1 | %FileCheck %s
+
+protocol P1 {
+  associatedtype A
+}
+
+// CHECK-LABEL: typed_throws.(file).f1@
+// CHECK-NEXT: Generic signature: <T where T : P1, T.[P1]A == Never>
+func f1<T: P1>(_: T) where () throws(T.A) -> () == () -> () {}
+
+// CHECK-LABEL: typed_throws.(file).f2@
+// CHECK-NEXT: Generic signature: <T where T : P1, T.[P1]A == any Error>
+func f2<T: P1>(_: T) where () throws(T.A) -> () == () throws -> () {}
+
+protocol P2 {
+  associatedtype A where A == () throws(E) -> ()
+  associatedtype E
+}
+
+// CHECK-LABEL: typed_throws.(file).f3@
+// CHECK-NEXT: Generic signature: <T where T : P2, T.[P2]E == Never>
+func f3<T: P2>(_: T) where T.A == () -> () {}
+
+// CHECK-LABEL: typed_throws.(file).f4@
+// CHECK-NEXT: Generic signature: <T where T : P2, T.[P2]E == any Error>
+func f4<T: P2>(_: T) where T.A == () throws -> () {}