// 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 : T:a<T where f
enum b {struct A
enum B}protocol a{
let a=f:A{var"
let a {
let c{
class d{{
}typealias d
{func f g
class A {
struct d<S where B{
let : N
< where h:a
var f
_}}}}
struct S<T where g:d {{{
class B{
var b{
<f
{let:d {
class b:d{
" {
var b{
let : d:A
struct d:d {
B{
struct B<T where " {{a
enum B<T where f: T> : a{var b=Swift.h =1
func f g
< where " ""
{}struct B<T where f: d< where B : T.h =1
< where h:A
func f g:a func
let a = " "
class d
func g a<T {var b {
class B<f=1
var b{
var f=
let : d:P {
class A class A class A{
class A {
}}protocol a=
func aA}
""
class b<f=
struct B<T> : {
B<T where B{var b:e}}struct S<f:P {
let a = " {
func foo}typealias d<T where f
func aA}
struct S<T where " {
let : T:e let:d{var"
var b {
"
func a
<T {let:d< {func a{{let:A
}}}
< where h: d
B{{
" " " "
func a=1
class A
var b{
{
where =1
class b<T where a = f: a=
protocol B:a = " [ 1
{{{
protocol B{
let a func
< where h: {
class A {}}
protocol a{var b {b{{
protocol B:a func
struct S<T where =f: {
{
enum :a<T where g:e let:d
struct S<T {
func A
protocol B{var f=
let c{
enum B:P {
enum S<T where B : d where a func
let a = " {var b:d where g:a<{{var""""
class B<f:A
struct S<h {var b {}typealias d< where h: d where f
class d<T where g:d<T where g
struct B{{
enum b {
protocol B{
protocol a
class A class B{
class A {
{
let a<T where B{
let : d:P {
struct A
enum S<f:d:e}}struct S<T where h:e
class d
let a func
class A<T where f=Swift.E
let a = f:d {
func g a
enum B<T where B : a{
func g a<T where g:d where g:d
func a
class a<T where " [ 1
class A {var b:d {b<T:a{
}protocol B}
class d{}
_}}typealias d
let a {var f=1
let c{var b {
class A
{
func aA}}}typealias d
func f g:a=f:P {{
class A {
protocol B}
func foo}}
let c<f=1
class A class {{
let : T:A{func g a{struct B{
<T {
class A {
class d<T where g:a
var b<T where g
func f g:a
protocol a<T where g:d<T where h:A
class A{
{
class d<S where f: {{
protocol a{
class a<T.e}}}}
let a{
{
enum S<f
class a{let:T
{b {{
func g a
var b:T>: T
func foo}
let a{
let : d:d
enum B{var b{a{struct S<T:A<T
<T
