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

typealias e : d where h: AnyObject
protocol A {
enum S<c {
typealias e : AnyObject
struct B<d where B : Boolean, A : A}
protocol c : Boolean, A : a
protocol A {enum S<T {
struct Q<T where h: a {
}
class b
class A : T:
}
let t: d where B { func b {
protocol A : Int = c<T {
class b {
typealias e =[Void
class d<T where h: A{
protocol A : a
}
protocol A : Boolean, A {
func < {
let a {
typealias e : B<T where B :
enum S<T : Int -> {
class A {
let f = c{
class a {
}
extension String {
class b
protocol c {() -> {
struct B { func c
struct Q<T where h: d {
typealias e : e:
class a {class
enum e)"[Void
let f = F>(a}
if true {
}
typealias e : b: a {
struct X<T where H:
struct d<T {let f = c
class a {
class A : p
if true {
typealias e : a{
class a {
{
class A : B
case c
}
func c,
protocol A : Boolean, A : Int -> {struct B<c : a {
struct A : A : A}
case c
protocol A : AnyObject
{
class a {
struct B:A
}
enum a
class b: A {
enum a
class d
class b<c {
class A : Boolean, A {
typealias e)"\() -> {
let t: A {
let a {
func j<T where g: AnyObject
case c<T where B { func g:a:
for ( )"[Void{
}
struct B
func a{
struct B<T where h: e)"[]struct Q<T where H : Boolean, A : P {enum a
struct X<T {
let a {
class a {{
func c( )
struct B<d where h: e)"[1)"[1)"\() -> {
}
}
class a {
{
}
class A {
protocol A {
class A}
let f = [Void
for ( )"[1)"[Void{
protocol c
typealias e : T:A
class a {
class A : Int -> {
let t: Boolean, A {
enum S<T where h: Int = []struct S<h {
extension String {
struct Q<h where h: A
}
struct Q<T {{
}
}func d<d {
}
class A : A
enum b{
class
protocol A : e
protocol A : d {
struct Q<T {
{
struct B : a {
typealias e : e:N
protocol A {
protocol A {
func a
for ( )"[1)"[Void
struct Q<T where h: e
extension String {
protocol c,
let t: C {
}
struct B<T where T
class A {}
typealias e : Boolean, A {
extension String {
struct B
let f = c<T where B :a
func A
struct Q<T where a
protocol A {
let a {
}
struct Q<T where h: p
struct Q<T where T
struct Q<T where h: e
let a {
struct d<T where B : b
struct S<h where h: A
enum S<T:
}
}
protocol A
protocol c : T:
{
case
func j<S : b<T where h: e)
class b: a
protocol A {
protocol A : a
case,
func c
var b {
typealias e : a=[Void{
typealias e : Boolean, A {
protocol A {
class b<T where g
protocol A : e)
protocol A {
enum S<d {
class
extension String {
typealias e : AnyObject
protocol c{
for ( )"\(
{
extension String {{
for ( )"[Void
func b
let f = [Void{
struct Q<T where d<T where h: a {