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

let a {
}
struct a
struct Q {
class A {
enum b { ()
{
struct B{
return
let l = B
struct d{ e () {
{{struct S<I:C{
{
{
class d:a{
{
if{struct B:B:d<T where S
0
struct S<e{
d
}
class A
{
}
init( ) {
" " " [ 1
enum A {
{
{}
import F
typealias B<T where B : b
}
}
}
let f = B<T where g
class a
{class a{
class x {}
}
struct S
struct S<T where g:d<e{
typealias e) {}
struct Q {
protocol c {
0
}
struct a
{
class A{
enum {
struct B<e{
}
protocol A{
func b
struct A{
{
enum A {
func d{}
{
}
{
{
}
}
}protocol e (
}
a {struct S<T , length: () -> Void{
}
func b
var _ T : b
}
var : b
{
func g: (
}
{
{
protocol c {
}
a<d
func i {}
}
}
}
func i {
struct A {
0
var : b
class B{
}}}
}
struct A {
}
struct A {
" " " [ 1
}
let closure: b(
" () -> Void in
}
}}
func g: b
struct d <e:a{
}
0
protocol c {
func a
" E
class a{
init( ) {
let a {
" E
func g: b
}
struct B{
var f=a{}
class x {
func g:B{
struct c { () -> Void{
a {
enum A {
struct A{
d<
}
}}}
protocol c {
A {
class a{
" [ 1
}
B {
}
" E
}}
struct S<Y {
struct B {
}
func g
}
class x {
}
struct S<I:e:d{
}
let l = B<T where g:t
}
class A{
d<T where g
}}protocol A{
import F
}
func g
}
}
class B<T where I:B
{class d<T where S<T where B : b
}
let l = B<e) = { e () {class B<T where g:e{
}
B : () {
}
{
struct B{
class x {
}
_ = b(
{
{
{
}
typealias B<i: b {
enum A {
}
enum b { e () {
_ = f = { )-> Void in
0
struct d <T where g:t
{
}}
func b
}protocol c {
}
func i {
}
struct B{
{
{
protocol c {
init( ) {
{
B {
protocol c { )-> Void{
}}}}
" " [ 1
}
typealias e:B<d
}
a<I:B
struct S
{
var f=a{
}
struct S
class a
}
var _ T where S<e{
}
{
" " (
if{
{
protocol c {
{
}
}
}
enum S<i: b {
{
func b
let a {
protocol e {
struct A {
{
struct a{
a{
a{struct A
typealias e{
}
class a{
{
struct d <e) = B<
}
" E
a {struct d:a
}
struct c
}
class A {
}
{{
{
protocol c {}
let a {
enum A {
protocol A{
}
a<T where g:d
}
protocol c {{
enum b {struct B
{
}
let f {
_ = { () -> {struct d <T where I
