// 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

>())
func g<1 {
let f = D> a {
}
extension A {
}
class func a<d = g<j : () {
f<b(n: l.B = ["
}
get {
}
enum b {
protocol c == [0)
""""\() {
self.a<Int>) {
var f.advance()
import Foundation
var d where S(i(v: B<T.Type) {
import Foundation
func a
case c>: a {
enum b {
return !)
class func c<T.e == B
d(n: A? = g<d
return nil
public var f(i: A {
}
}
a() {
typealias h, ()
struct c {
}
map(true }
print())-> String {
b(b(() -> V {
}
func a
case A"
class A> e() {
func i: ()
enum B : end)) {
class A? {
self.e where l) -> String {
}
}
class func f.d {
}
return [1):
}
}
convenience init() {
print() {
let a {
}
let a {
}
}
protocol A {
let a
var b<T) -> Self {
default:
typealias B
S.Generator.f : S<b(A(A>() -> T {
protocol b {
}
init(#object1, k : AnyObject.c
typealias d((b(b
return $0
return NSData(a)
}
}
}
protocol d where A<T>) {
class A {
}
}
let h> {
let h = Swift.advance(A, length: A<D> : B)
var d {
func f.Generator.A"
func e<d<D>()
}
protocol a {
S<d
typealias B
}
}
func d
func e(false))
func e!
}
}
}
class A<T where T : String {
func f: a {
typealias b = b: d {
}
class B : SequenceType> ()
}
}
}
