Remove pub from core::{unicode,cmath,stackwalk,rt} by alexcrichton · Pull Request #6226 · rust-lang/rust

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

alexcrichton · 2013-05-03T21:15:38Z

I just removed pub mod from core.rc and then got everything to compile again. One thing I'm worried about is an import like this:

use a;use a::b;mod a {pubtypeb = int;}mod b {use a;// baduse a::b;// good}

I'm not sure if use a::b being valid is a bug or intended behavior (same question about use a). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

catamorphism · 2013-05-03T22:30:51Z

I think use a::b shouldn't be allowed if a is private, regardless of whether b is public.

alexcrichton · 2013-05-03T23:30:58Z

If you can't use anything out of a non-pub mod, then what's the point of having one?

alexcrichton · 2013-05-04T14:55:29Z

cc #6199

brson · 2013-05-06T20:16:02Z

@alexcrichton siblings can access items in private mods

mod a { fn foo() { } }
// I can access foo
a::foo()

brson · 2013-05-06T20:22:04Z

I r+'d because I want those modules to be private, but I do think this is exploiting a resolve bug.

I think that absolute path resolution always assumes that private mods are inaccessible, even when the path is stated in a module that should have access to the path. e.g.

priv mod a { pub fn b() }
priv mod c {
use a::b; // a is private so resolve thinks we can't access it, even though `c` is a sibling of `a`
}

Relative paths do work

priv mod a { pub fn b() }
priv mod c {
use super::a::b;
}

imo this is bogus, and visibility should be interpreted the same way for either absolute or relative paths.

alexcrichton · 2013-05-06T20:33:47Z

So just out of curiosity, let's say that there's a private module m.

This means that within m, all members (not sub-modules) can access any private/public member of m.
All child modules of m (and their children) cannot access private members of m, but they can access public members?
All siblings of the module m can access all the public members of m
Nothing else can access any member of m

Are those true? Additionally, is there a section in the manual or some documentation explaining all this? If not, I'd be willing to take a stab at writing something up (in addition to looking into the resolve bugs if they exist).

I just removed `pub mod` from `core.rc` and then got everything to compile again. One thing I'm worried about is an import like this: ```rust use a; use a::b; mod a { pub type b = int; } mod b { use a; // bad use a::b; // good } ``` I'm not sure if `use a::b` being valid is a bug or intended behavior (same question about `use a`). If it's intended behavior, then I got around these modules not being public by only importing the specific members that are necessary. Otherwise that probably needs an open issue.

alexcrichton · 2013-05-07T03:50:19Z

I opened a subsequent issue to deal with the resolve bugs (cc'd previously)

Add lint for comparing to empty slices instead of using .is_empty() Hey first time making a clippy lint I added the implementation of the lint the `len_zero` since it shared a lot of the code, I would otherwise have to rewrite. Just tell me if the lint should use it's own file instead changelog: Add lint for comparing to empty slices Fixesrust-lang#6217

6207: Extract ImportAssets out of auto_import r=matklad a=Veykril See rust-lang/rust-analyzer#6172 (comment) I couldn't fully pull out `AssistContext` as `find_node_at_offset_with_descend`: https://github.com/rust-analyzer/rust-analyzer/blob/81fa00c5b5d5ffb559a39c7ff5190a2519a8ea61/crates/assists/src/assist_context.rs#L90-L92 requires the `SourceFile` which is private in it and I don't think making it public just for this is the right call? 6224: ⬆️ salsa r=matklad a=matklad bors r+ 🤖 6226: Add reminder to update lsp-extensions.md r=matklad a=matklad bors r+ 🤖 6227: Reduce bors timeout r=matklad a=matklad bors r+ 🤖 Co-authored-by: Lukas Wirth <lukastw97@gmail.com> Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Remove pub from core::{unicode,cmath,stackwalk,rt}
24cda9f

bors closed this May 7, 2013

bors merged commit 24cda9f into rust-lang:incomingMay 7, 2013

This was referenced May 7, 2013
Stop exporting core::rt,unicode,cmath,stackwalk,rt #6199
Closed
Unadorned path should resolve same as relative path written w.r.t. self/super #6291
Closed

alexcrichton deleted the issue-6199 branch May 7, 2013 03:49

Uh oh!

Uh oh!

Conversation

alexcrichton commented May 3, 2013

Uh oh!

catamorphism commented May 3, 2013

Uh oh!

alexcrichton commented May 3, 2013

Uh oh!

alexcrichton commented May 4, 2013

Uh oh!

brson commented May 6, 2013

Uh oh!

brson commented May 6, 2013

Uh oh!

alexcrichton commented May 6, 2013

Uh oh!

alexcrichton commented May 7, 2013

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Uh oh!

Uh oh!

Conversation

alexcrichton commented May 3, 2013

Uh oh!

catamorphism commented May 3, 2013

Uh oh!

alexcrichton commented May 3, 2013

Uh oh!

alexcrichton commented May 4, 2013

Uh oh!

brson commented May 6, 2013

Uh oh!

brson commented May 6, 2013

Uh oh!

alexcrichton commented May 6, 2013

Uh oh!

alexcrichton commented May 7, 2013

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Uh oh!

Uh oh!

Conversation

alexcrichton commented May 3, 2013

Uh oh!

catamorphism commented May 3, 2013

Uh oh!

alexcrichton commented May 3, 2013

Uh oh!

alexcrichton commented May 4, 2013

Uh oh!

brson commented May 6, 2013

Uh oh!

brson commented May 6, 2013

Uh oh!

alexcrichton commented May 6, 2013

Uh oh!

alexcrichton commented May 7, 2013

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!