// 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 func a{
struct B<h
protocol P{
protocol c : a {
}
func a<T where B<h:P{V
let end = [Void{
let i: T where B : A {
class d:a{
protocol h : a {
func f:P{
protocol A {
struct B<T {let b {
case c:P{
func a{class A {
var f:P{
protocol A {
protocol e : a {
protocol b : A {class C<A {
let end = [Void{
func a h:b {
import CoreData
protocol b {
func a<c,
class C<c:a
func a
protocol A {
}
}struct Q<T {
func a{
typealias F
typealias e : b : d where B : C {
struct B<T where I:N
}
class A : A {
struct B<T where B<T {func a{
struct A : C {
}
class a
class d:a<T where B :b
return "
case c,
}
}
protocol b : a {struct B<h : a {
struct B<h : a h
struct A {
typealias F
enum S<T where g: A {
func g<A {
struct B<T where f:b{class A : T where B : T where B : a {
class c : a
func a<T where f:P{
func a() {
}
struct B<T where B : b {
func a {class d:e
struct B<b{let a {
init( )
import CoreData
}
protocol c : a h:P{
struct Q<T where B : b {
struct A {var f<Int>(a{
protocol A {
protocol A : a {
typealias A
b
var d{
return "
class a
}
class func g: a {
init( ) {func a<b
let end = [Void{
class a<c,
a {
struct A {
protocol A {var d:a{
class a<T: T {
var e}
typealias e : a {
struct Q<h:P{class c : b {class d:e
}
protocol b class C<Int>
}
protocol c : a {
let v: a {var e}
protocol A {
}
protocol h : A : A : a {
protocol b{
let v: a {
protocol A : C {
let a {
let v: a {
struct B:a
struct Q<T {
}
class a<A {
protocol b {
typealias A
let v: a {
protocol c : a {
protocol e : T where B<A {class func g: A {
let v: C {
[0
}
}
var d{
typealias b {
struct B:b : a<T: b {func g: C {
case c,
init( ) {
struct Q<Int>(a< where f<T where g
}class C<T {
protocol a {
let b {class a< where g<T {
struct B<T where B :a
struct B<T: b( )
typealias A
protocol A : a {
let a {
protocol A : T: C {
typealias F
protocol h : b
}struct B<h : a {
}
}
}struct B<h:a{
let a {func a {
case c,
class A {
typealias A
protocol b {
protocol P{
protocol e : T where B<A {
}
var f:b
class A : d where g: C {
class a{
func a{struct A {
protocol e : A {
class a(a
b
let v: B<b
protocol e : C {
protocol A : B:P{
init( ) {
protocol A {var d{
protocol A {
struct B<T where B<T where g: a {
func g<T {
import CoreData
protocol A {
typealias A
struct A : A : d {
func g: b {
let b {class C<h : T where B:b {
}
func g: d where I:a
struct B<Int>
protocol b class func f:P{}class func a
