// 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 b
typealias e
let end = " \ (
{
{}
class d
protocol a T {
struct Q<T{class B<T where f={
if true {
class C(object1: a{
struct d=true {
let end = " )
struct Q<T {c d<T> : Any)
}class c{
typealias b
let a {}
struct c{
enum S<T where B<h:b
a : d<T> : d<T NSObject {
var f=true {
}
protocol A {
struct d<T{
class C{
if true as S<T>
func a()
let f={
}
enum B{
}
class a {{
protocol A {
var _=(object1 : d<T T{
for c d<T where f={
func g<T T>
if true {
class a {
class d<T where
class A{struct d<
func<T where B : d {
}
protocol A:{struct e.b
}}
class c{
protocol A{
func g:A{class
{
protocol P{}class d<h:{}
enum B{
enum S<T{class C
if true {
let a : whe
if true {c e=e="""
class c{
protocol a {var e
}struct D : a
ifruct
var e=(object1 : a {
class C{
struct d<T where B : whe
class a : d<T {class B
enum B
class C{
let end = " \ ()
{
class c{{typealias b
var f={
let end = D> ) {
class a T NSObject {
struct D : a
func g:{
func a(object1 : = D> : d<T NSObject {
struct B:A? {
class C
struct B
func " )
func T{
func g: d<T where g<T where g:e:C(
func g:b
func g: T) {
enum S
struct Q<T {class B{
struct B
protocol A {
class B< T where B<T NSObject {
}
}}
struct e()
}protocol a T {}
class c{
typealias e={
if true {
class c{let f={}
class A<T) {
func g<T : T>
{class C
class c{
{
class c{}
}
enum S<T{
}protocol b
func a{}
a {
var _=(object1: a()
}
{
class b
if true {c d<T where T> : d<T where B
{
}
"[1
let:A:A{class A{
}
a : Any)
func g:C
{
struct B{
class a"\ (object1 : = " )
}
func T) {{let end = B
class A{}
}
struct e:e.b
func a
class d<T where
var f={
func<T NSObject {
if true {
{
for c e={
struct B{
struct d<T{
func T> ) {
struct c{
enum B
}
protocol A {
enum B{
{
protocol P{
protocol P{
}
if true{}
for c e="[1
func a(
for c d
var f {{
let end = " )
class d=true {let f="
protocol A? {
func T>
enum S<T where B : A{}
{
}
struct B< T {
class C{
}
let f: d
}
struct Q<l where g:A{
class d<T where g<h:{
{
func T{
}protocol P{
a : a(
enum k
protocol P{
struct B
}class a T where B : a
if true{
{}
class A{
}class a {var d
{
{
enum B
struct d
if true {
class A{class d<
var b ="[1
func a
if true {}
class c{
var e(object1: a<T where B<T where B : Any