// RUN: not %target-swift-frontend %s -parse

// Distributed under the terms of the MIT license
// Test case submitted to project by https://github.com/practicalswift (practicalswift)
// Test case found by fuzzing


class c {
struct c) {
typealias b = B
return [B
}
extension A = h, i: A, a()
func g> {
}
}
t: (2, end)
return $0
return [1, e = a: k) -> A {
}
}
typealias E
}
convenience init(n: T) -> {
protocol c where T> : String {
print())
typealias e where T> {
}
t: (start: (p: SequenceType> a {
}
public class a = 0
}
return """)-> T>() -> S : A {
typealias d.advance() -> {
return nil
}
f(m()
print()
}
}
case s: b: Int
}
return g: () {
}
protocol A {
}
}
func d.advance(n: e)
let n1: c : ()
let b = T>(A<j : a {
}
return b(x("))")
protocol e == [B<D>()
class func a(i(_ c>(Any, A<T -> <H : ExtensibleCollectionType>().b: b(start: Int -> {
f))
}
})
}
func g<e<l : [B<e: a {
func b
}
}
}
}
}
}
}
}
case b where Optional<T where T : AnyObject) {
func c: P {
default:Any, (false)
func g.A.Type) -> (""a(.B
func b, 3] == {
return [c
class C(p: () -> T) -> U -> {
return z: e<h : NSObject {}
let t: d {
protocol a {
return ""[unowned self, x {
typealias F = c: C())
class func d<T, U) -> Any, A.dynamicType)() -> T>
init()
}
class b: BooleanType)
typealias g<U : P> String
}
}
(t: d {
func b[1, self.e == b.b : A, B
}
}
enum A {
var d : d = b: B<T>) -> {
}
class B = [](")
protocol A {
}
func b> [Int]].c<c
case b {
protocol C {
return nil
class A {
return nil
}
}
}
import Foundation
struct A, V, object2)
func b<H : Range<d>?
class func c() -> {
}
var d = b, AnyObj
