83d2c0b8a6
Resolve is currently erroneously allowing imports through private `use`
statements in some circumstances, even across module boundaries. For example,
this code compiles successfully today:
use std::c_str;
mod test {
use c_str::CString;
}
This should not be allowed because it was explicitly decided that private `use`
statements are purely bringing local names into scope, they are not
participating further in name resolution.
As a consequence of this patch, this code, while valid today, is now invalid:
mod test {
use std::c_str;
unsafe fn foo() {
::test::c_str::CString::new(0 as *u8, false);
}
}
While plausibly acceptable, I found it to be more consistent if private imports
were only considered candidates to resolve the first component in a path, and no
others.
Closes #12612
59 lines
1.5 KiB
Rust
59 lines
1.5 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
extern crate serialize;
|
|
|
|
use serialize::{Encodable, Encoder};
|
|
use serialize::json;
|
|
use serialize::ebml::writer;
|
|
use std::io::MemWriter;
|
|
use std::str::from_utf8_owned;
|
|
|
|
#[deriving(Encodable)]
|
|
struct Foo {
|
|
baz: bool,
|
|
}
|
|
|
|
#[deriving(Encodable)]
|
|
struct Bar {
|
|
froboz: uint,
|
|
}
|
|
|
|
enum WireProtocol {
|
|
JSON,
|
|
EBML,
|
|
// ...
|
|
}
|
|
|
|
fn encode_json<'a,
|
|
T: Encodable<json::Encoder<'a>,
|
|
std::io::IoError>>(val: &T,
|
|
wr: &'a mut MemWriter) {
|
|
let mut encoder = json::Encoder::new(wr);
|
|
val.encode(&mut encoder);
|
|
}
|
|
fn encode_ebml<'a,
|
|
T: Encodable<writer::Encoder<'a, MemWriter>,
|
|
std::io::IoError>>(val: &T,
|
|
wr: &'a mut MemWriter) {
|
|
let mut encoder = writer::Encoder(wr);
|
|
val.encode(&mut encoder);
|
|
}
|
|
|
|
pub fn main() {
|
|
let target = Foo{baz: false,};
|
|
let mut wr = MemWriter::new();
|
|
let proto = JSON;
|
|
match proto {
|
|
JSON => encode_json(&target, &mut wr),
|
|
EBML => encode_ebml(&target, &mut wr)
|
|
}
|
|
}
|