1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
// RUN: %batch-code-completion
enum Either<T,U> { case first(T), second(U) }
indirect enum ResultBuilderTerm<Expression> {
case expression(Expression)
case block([ResultBuilderTerm])
case either(Either<ResultBuilderTerm, ResultBuilderTerm>)
}
protocol ResultBuilder {
associatedtype Expression
typealias Component = ResultBuilderTerm<Expression>
associatedtype FinalResult
static func buildFinalResult(_ component: Component) -> FinalResult
}
extension ResultBuilder {
static func buildExpression(_ expression: Expression) -> Component { .expression(expression) }
static func buildBlock(_ components: Component...) -> Component { .block(components) }
static func buildEither(first: Component) -> Component { .either(.first(first)) }
static func buildEither(second: Component) -> Component { .either(.second(second)) }
}
@resultBuilder
enum ArrayBuilder<E>: ResultBuilder {
typealias Expression = E
typealias FinalResult = [E]
static func buildFinalResult(_ component: Component) -> FinalResult {
switch component {
case .expression(let e): return [e]
case .block(let children): return children.flatMap(buildFinalResult)
case .either(.first(let child)): return buildFinalResult(child)
case .either(.second(let child)): return buildFinalResult(child)
}
}
}
func test(@ArrayBuilder<Int> a: () -> [Int]) {}
enum MyEnum { case a, b }
test {
switch MyEnum.a {
case .#^EMPTYCASE?check=MYENUM_MEMBERS^#
}
}
test {
switch MyEnum.a {
case .a:
case .#^SECONDEMPTYCASE?check=MYENUM_MEMBERS^#
}
}
// MYENUM_MEMBERS-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: a[#MyEnum#]; name=a
// MYENUM_MEMBERS-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: b[#MyEnum#]; name=b
|
