The code isn't valid; you can't use a weak reference with Any. (Just because the compiler fails to emit an error doesn't mean the code is valid; maybe that's the bug, like it is here.)

@swift-ci create

Comment by Mo Ramezanpoor (JIRA)

Thanks, you’re right. I used “valid” incorrectly there. Though that doesn’t actually make a difference if you check the other samples. Using `AnyObject`, or even a concert type still causes it to crash. Given:

class MyClass {}
func outer(_ work: (MyClass) -> Void) {}
func inner(_ work: (() -> Void)) {}

outer { captured in
    inner { [weak captured] in
    }
}

We have a segfault with this output:

While silgen closureexpr SIL function "@_T03BugyAA7MyClassCcfU_".
 for expression at [<path>/Bug.swift:5:7 - line:8:1] RangeText="{ captured in
    inner { [weak captured] in
    }
}"

which made me think the issue is in SILGen.

Comment by Mo Ramezanpoor (JIRA)

I’ve managed to narrow down what the problem is, but I’m not sure how it should be fixed:

1. The type checker performs a pre-check before solving the types of `outer` invocation. here

2. As part of the pre-check, if it’s a single-expression closure, it’ll pre-check the body, which is `inner` invocation. here

3. The inner closure’s capture list is type checked during this pre-check. here

4. The problem is the outer `captured` does not have a type at this point. This causes it to be marked as invalid. here

5. The invalid type is propagated to the captured list:

   (var_decl "captured" type='<<error type>>' interface type='<<error type>>' access=private storage_kind=stored)
     
   

6. The type checker then continues and “fixes” the outer `captured`’s type, but the inner type is not fixed: here

   (parameter "captured" type='AnyObject' interface type='AnyObject')
      
   

7. Later, this is caught by the AST verifier, which aborts the process. here

The bug only occurs when the closure is single-expression. This, for example, compiles fine:

outer { captured in
    1
    inner { [weak captured] in
    }
}