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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// This source file is part of the Swift.org open source project
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
// RUN: not %target-swift-frontend %s -typecheck
protocol a {
class func c()
}
class b: a {
c T) {
}
f(true as Boolean)
func f() {
({})
}
import Foundation
class Foo<T>: 1)
func c<d {
enum c {
func e
var _ = e
}
}
struct c<d : Sequence> {
var b: d
}
func a<enum b {
case c
}
}
func String {\(with): \(g())" } i {}
struct A<T> {
let a: [(T, () -> ())] = []
}
f
e)
func f<g>() -> (g, g -> g) -> g {
d j d.i 1, a(2, 3)))
class a {
typealias b = b
}
func i(c: () -> ()) {
}
class a {
var _ = i() {
}
}
class a<f : b, g : b where f.d == g> {
}
protocol b {
typealias d
typealias e
}
struct c<h : b> : b {
typealias d = h
typealias e = a<c<h>, d>
}
func a(b: Int = 0) {
}
let c = a
c()
protocol A {
typealias B
}
class C<D> {
init <A: A where A.B == D>(e: A.B) {
}
}
func e<k>() -> (k, k -> k) -> k {
f j f.i = {
}
{
k) {
n }
}
m e {
class func i()
}
class f: e{ class func i {}
func n<i>() {
k k {
f j
}
-> T) -> String {
return { g in "\(with): \(g())" }
}
struct d<f : e, g: e where g.h == f.h> {
}
protocol e {
typealias h
}
protocol a : a {
}
func a<T>() -> (T, T -> T) -> T)!c : b { func b
protocol A {
typeal= D>(e: A.B) {
}
}
var x1 = 1
var f1: Int -> Int = {
return $0
}
let succee""
}
}
class C: B, A {
override func d() -> String {
return ""
}
func}
class c {
func b((Any, c))(Any, AnyObject
typealias b = b
}
struct A<T> {
let a: [(T, () -> ())] = []
}
|
