rustc: Tweak the borrow on closure invocations #13686

alexcrichton · 2014-04-22T15:50:40Z

This alters the borrow checker's requirements on invoking closures from
requiring an immutable borrow to requiring a unique immutable borrow. This means
that it is illegal to invoke a closure through a & pointer because there is no
guarantee that is not aliased. This does not mean that a closure is required to
be in a mutable location, but rather a location which can be proven to be
unique (often through a mutable pointer).

For example, the following code is unsound and is no longer allowed:

type Fn<'a> = ||:'a;                                                         

fn call(f: |Fn|) {                                                           
    f(|| {                                                                   
        f(|| {})                                                             
    });                                                                      
}                                                                            

fn main() {                                                                  
    call(|a| {                                                               
        a();                                                                 
    });                                                                      
}

There is no replacement for this pattern. For all closures which are stored in
structures, it was previously allowed to invoke the closure through &self but
it now requires invocation through &mut self.

The standard library has a good number of violations of this new rule, but the
fixes will be separated into multiple breaking change commits.

Closes #12224

brson · 2014-04-22T18:32:27Z

cc @nikomatsakis

flaper87 · 2014-04-22T22:44:42Z

src/librustc/middle/borrowck/mod.rs

@@ -676,6 +677,9 @@ impl<'a> BorrowckCtxt<'a> {
                    AddrOf | RefBinding | AutoRef => {
                        format!("cannot borrow {} as mutable", descr)
                    }
+                    ClosureInvocation => {
+                        format!("cannot reborrow {} while it's invoked", descr)


I couldn't find a test for this error in this PR. Could you add one?

nikomatsakis · 2014-04-23T00:27:30Z

r+ This looks good modulo nits.

This alters the borrow checker's requirements on invoking closures from requiring an immutable borrow to requiring a unique immutable borrow. This means that it is illegal to invoke a closure through a `&` pointer because there is no guarantee that is not aliased. This does not mean that a closure is required to be in a mutable location, but rather a location which can be proven to be unique (often through a mutable pointer). For example, the following code is unsound and is no longer allowed: type Fn<'a> = ||:'a; fn call(f: |Fn|) { f(|| { f(|| {}) }); } fn main() { call(|a| { a(); }); } There is no replacement for this pattern. For all closures which are stored in structures, it was previously allowed to invoke the closure through `&self` but it now requires invocation through `&mut self`. The standard library has a good number of violations of this new rule, but the fixes will be separated into multiple breaking change commits. Closes rust-lang#12224 [breaking-change]

Many iterators go through a closure when dealing with the `idx` method, which are invalid after the previous change (closures cannot be invoked through a `&` pointer). This commit alters the `fn idx` method on the RandomAccessIterator to take `&mut self` rather than `&self`. [breaking-change]

This is similar to the previous commits to allow invocation of a closure through a `&mut self` pointer because `&self` is disallowed. One of the primary implementors of the CharEq trait is a closure type, which would not work if the method continued to have `&self`. In addition to changing mutability of the `matches` method, this modifies the following methods from &CharEq to take a type which implements CharEq by value. * trim_chars * trim_left_chars * trim_right_chars Where these methods were previously invoked via s.trim_chars(&'a') it would now be invoked through s.trim_chars('a') [breaking-change]

As with the previous commits, the Finally trait is primarily implemented for closures, so the trait was modified from `&self` to `&mut self`. This will require that any closure variable invoked with `finally` to be stored in a mutable slot. [breaking-change]

This fixes various issues throughout the standard distribution and tests.

This alters the borrow checker's requirements on invoking closures from requiring an immutable borrow to requiring a unique immutable borrow. This means that it is illegal to invoke a closure through a `&` pointer because there is no guarantee that is not aliased. This does not mean that a closure is required to be in a mutable location, but rather a location which can be proven to be unique (often through a mutable pointer). For example, the following code is unsound and is no longer allowed: type Fn<'a> = ||:'a; fn call(f: |Fn|) { f(|| { f(|| {}) }); } fn main() { call(|a| { a(); }); } There is no replacement for this pattern. For all closures which are stored in structures, it was previously allowed to invoke the closure through `&self` but it now requires invocation through `&mut self`. The standard library has a good number of violations of this new rule, but the fixes will be separated into multiple breaking change commits. Closes #12224

Don't show runnable code lenses in libraries outside of the workspace Addresses rust-lang#13664. For now I'm just disabling runnable code lenses since the ones that display the number of references and implementations do work correctly with external code. Also made a tiny TypeScript change to use the typed `sendNotification` overload.

flaper87 reviewed Apr 22, 2014
View reviewed changes

alexcrichton added 5 commits April 23, 2014 10:03

Fix other bugs with new closure borrowing

823c7ee

This fixes various issues throughout the standard distribution and tests.

alexcrichton mentioned this pull request Apr 23, 2014

add regexp crate to Rust distribution (implements RFC 7) #13700

Merged

bors closed this Apr 23, 2014

bors merged commit 823c7ee into rust-lang:master Apr 23, 2014

alexcrichton deleted the issue-12224 branch April 24, 2014 03:25

jcmoyer mentioned this pull request Apr 24, 2014

Use &mut closure to satisfy the borrow checker Rust-SDL2/rust-sdl2#83

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

rustc: Tweak the borrow on closure invocations #13686

rustc: Tweak the borrow on closure invocations #13686

alexcrichton commented Apr 22, 2014

brson commented Apr 22, 2014

flaper87 Apr 22, 2014

nikomatsakis commented Apr 23, 2014

rustc: Tweak the borrow on closure invocations #13686

rustc: Tweak the borrow on closure invocations #13686

Conversation

alexcrichton commented Apr 22, 2014

brson commented Apr 22, 2014

flaper87 Apr 22, 2014

Choose a reason for hiding this comment

nikomatsakis commented Apr 23, 2014