averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

RequirementMachine: Conditional requirement inference

Browse Source 
If a type parameter is subject to both a conformance requirement
and a concrete type requirement, the concrete type might conform
conditionally.

In this case, introduce new requirements to satisfy the conditional
conformance.

Since this can add new hitherto-unseen protocols to the rewrite
system, restrict this feature to top-level generic signatures, and
not protocol requirement signatures. Allowing this to occur in
protocol requirement signatures would change the connectivity of
the protocol dependency graph (and hence the connected components)
during completion, which would be a major complication in the
design. The GSB already enforces this restriction.

I changed the existing conditional_requirement_inference.swift test
to run with -requirement-machine-inferred-signatures=verify. Since
one of the test cases there triggers an unrelated bug in the
Requirement Machine, I split it off into a new file named
conditional_requirement_inference_2.swift which still runs with
the GSB. Once the bug is fixed I'll merge the files again.
This commit is contained in:
Slava Pestov
2022-01-22 00:20:27 -05:00
parent 75dfab00b9
commit eb9f12109e
7 changed files with 176 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
test/Generics/conditional_requirement_inference.swift
View File

@@ -1,58 +1,25 @@
// RUN: %target-typecheck-verify-swift
// RUN: not %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
// RUN: %target-swift-frontend -typecheck -debug-generic-signatures -requirement-machine-inferred-signatures=verify %s 2>&1 | %FileCheck %s
protocol Equatable {}
struct Array<Element> {}
extension Array : Equatable where Element : Equatable {}
// Valid example
struct EquatableBox<T : Equatable> {
// CHECK: Generic signature: <T, U where T == Array<U>, U : Equatable>
func withArray<U>(_: U) where T == Array<U> {}
}
struct EquatableSequenceBox<T : Sequence> where T.Element : Equatable {
// CHECK: Generic signature: <T, U where T == Array<Array<U>>, U : Equatable>
func withArrayArray<U>(_: U) where T == Array<Array<U>> {}
}
// A conditional requirement with a protocol we haven't seen before.
protocol First {}
protocol Second {}
// A very elaborate invalid example (see comment in mergeP1AndP2())
struct G<T> {}
extension Array : First where Element : Second {}
protocol P {}
extension G : P where T : P {}
protocol P1 {
associatedtype T
associatedtype U where U == G<T>
associatedtype R : P1
}
protocol P2 {
associatedtype U : P
associatedtype R : P2
}
func takesP<T : P>(_: T.Type) {}
// expected-note@-1 {{where 'T' = 'T.T'}}
// expected-note@-2 {{where 'T' = 'T.R.T'}}
// expected-note@-3 {{where 'T' = 'T.R.R.T'}}
// expected-note@-4 {{where 'T' = 'T.R.R.R.T'}}
// CHECK: Generic signature: <T where T : P1, T : P2>
func mergeP1AndP2<T : P1 & P2>(_: T) {
// P1 implies that T.(R)*.U == G<T.(R)*.T>, and P2 implies that T.(R)*.U : P.
//
// These together would seem to imply that G<T.(R)*.T> : P, therefore
// the conditional conformance G : P should imply that T.(R)*.T : P.
//
// However, this would require us to infer an infinite number of
// conformance requirements in the signature of mergeP1AndP2() of the
// form T.(R)*.T : P.
//
// Since we're unable to represent that, make sure that a) we don't crash,
// b) we reject the conformance T.(R)*.T : P.
takesP(T.T.self) // expected-error {{global function 'takesP' requires that 'T.T' conform to 'P'}}
takesP(T.R.T.self) // expected-error {{global function 'takesP' requires that 'T.R.T' conform to 'P'}}
takesP(T.R.R.T.self) // expected-error {{global function 'takesP' requires that 'T.R.R.T' conform to 'P'}}
takesP(T.R.R.R.T.self) // expected-error {{global function 'takesP' requires that 'T.R.R.R.T' conform to 'P'}}
}
struct SillyBox<T : First> {
// CHECK: Generic signature: <T, U where T == Array<U>, U : Second>
func withArray<U>(_: U) where T == Array<U> {}
}