OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

librustc: Forbid external crates, imports, and/or items from being

Browse Source 
declared with the same name in the same scope.

This breaks several common patterns. First are unused imports:

    use foo::bar;
    use baz::bar;

Change this code to the following:

    use baz::bar;

Second, this patch breaks globs that import names that are shadowed by
subsequent imports. For example:

    use foo::*; // including `bar`
    use baz::bar;

Change this code to remove the glob:

    use foo::{boo, quux};
    use baz::bar;

Or qualify all uses of `bar`:

    use foo::{boo, quux};
    use baz;

    ... baz::bar ...

Finally, this patch breaks code that, at top level, explicitly imports
`std` and doesn't disable the prelude.

    extern crate std;

Because the prelude imports `std` implicitly, there is no need to
explicitly import it; just remove such directives.

The old behavior can be opted into via the `import_shadowing` feature
gate. Use of this feature gate is discouraged.

This implements RFC #116.

Closes #16464.

[breaking-change]
This commit is contained in:
Patrick Walton 2014-08-12 20:31:30 -07:00
parent 85fd37f876
commit 7f928d150e
86 changed files with 579 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/doc/guide-unsafe.md
View File

@ -537,11 +537,12 @@ extern crate core;
use core::prelude::*;
use core::mem;
use core::raw::Slice;
#[no_mangle]
pub extern fn dot_product(a: *const u32, a_len: u32,
b: *const u32, b_len: u32) -> u32 {
use core::raw::Slice;
// Convert the provided arrays into Rust slices.
// The core::raw module guarantees that the Slice
// structure has the same memory layout as a &[T]

3
src/libcollections/bitv.rs
View File

@ -68,12 +68,11 @@ use core::default::Default;
use core::fmt;
use core::iter::Take;
use core::iter;
use core::ops::Index;
use core::slice;
use core::uint;
use std::hash;
use {Collection, Mutable, Set, MutableSet, MutableSeq};
use {Mutable, Set, MutableSet, MutableSeq};
use vec::Vec;

2
src/libcollections/btree.rs
View File

@ -24,7 +24,7 @@ use alloc::boxed::Box;
use core::fmt;
use core::fmt::Show;
use {Collection, MutableSeq};
use MutableSeq;
use vec::Vec;
#[allow(missing_doc)]

2
src/libcollections/dlist.rs
View File

@ -31,7 +31,7 @@ use core::mem;
use core::ptr;
use std::hash::{Writer, Hash};
use {Collection, Mutable, Deque, MutableSeq};
use {Mutable, Deque, MutableSeq};
/// A doubly-linked list.
pub struct DList<T> {

9
src/libcollections/lib.rs
View File

@ -22,9 +22,12 @@
html_playground_url = "http://play.rust-lang.org/")]
#![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
#![feature(unsafe_destructor)]
#![feature(unsafe_destructor, import_shadowing)]
#![no_std]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[phase(plugin, link)] extern crate core;
extern crate unicode;
extern crate alloc;
@ -36,11 +39,11 @@ extern crate alloc;
#[cfg(test)] #[phase(plugin, link)] extern crate std;
#[cfg(test)] #[phase(plugin, link)] extern crate log;
use core::prelude::*;
use core::prelude::Option;
pub use core::collections::Collection;
pub use bitv::{Bitv, BitvSet};
pub use btree::BTree;
pub use core::prelude::Collection;
pub use dlist::DList;
pub use enum_set::EnumSet;
pub use priority_queue::PriorityQueue;

2
src/libcollections/priority_queue.rs
View File

@ -154,7 +154,7 @@ use core::default::Default;
use core::mem::{zeroed, replace, swap};
use core::ptr;
use {Collection, Mutable, MutableSeq};
use {Mutable, MutableSeq};
use slice;
use vec::Vec;

3
src/libcollections/ringbuf.rs
View File

@ -18,11 +18,10 @@ use core::prelude::*;
use core::cmp;
use core::default::Default;
use core::fmt;
use core::iter::RandomAccessIterator;
use core::iter;
use std::hash::{Writer, Hash};
use {Deque, Collection, Mutable, MutableSeq};
use {Deque, Mutable, MutableSeq};
use vec::Vec;
static INITIAL_CAPACITY: uint = 8u; // 2^3

13
src/libcollections/slice.rs
View File

@ -86,23 +86,22 @@ for &x in numbers.iter() {
#![doc(primitive = "slice")]
use core::prelude::*;
use core::cmp;
use core::mem::size_of;
use core::mem;
use core::prelude::{Clone, Collection, Greater, Iterator, Less, None, Option};
use core::prelude::{Ord, Ordering, RawPtr, Some, range};
use core::ptr;
use core::iter::{range_step, MultiplicativeIterator};
use {Collection, MutableSeq};
use MutableSeq;
use vec::Vec;
pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
pub use core::slice::{Chunks, Slice, ImmutableSlice, ImmutablePartialEqSlice};
pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
pub use core::slice::{MutSplits, MutChunks};
pub use core::slice::{bytes, MutableCloneableSlice};
pub use core::slice::{BinarySearchResult, Found, NotFound};
pub use core::slice::{MutSplits, MutChunks, Splits};
pub use core::slice::{bytes, ref_slice, MutableCloneableSlice};
pub use core::slice::{Found, NotFound};
// Functional utilities

2
src/libcollections/smallintmap.rs
View File

@ -21,7 +21,7 @@ use core::iter;
use core::iter::{Enumerate, FilterMap};
use core::mem::replace;
use {Collection, Mutable, Map, MutableMap, MutableSeq};
use {Mutable, Map, MutableMap, MutableSeq};
use {vec, slice};
use vec::Vec;
use hash;

8
src/libcollections/str.rs
View File

@ -69,15 +69,17 @@ is the same as `&[u8]`.
#![doc(primitive = "str")]
use core::prelude::*;
use core::default::Default;
use core::fmt;
use core::cmp;
use core::iter::AdditiveIterator;
use core::mem;
use core::prelude::{Char, Clone, Collection, Eq, Equiv, ImmutableSlice};
use core::prelude::{Iterator, MutableSlice, None, Option, Ord, Ordering};
use core::prelude::{PartialEq, PartialOrd, Result, Slice, Some, Tuple2};
use core::prelude::{range};
use {Collection, Deque, MutableSeq};
use {Deque, MutableSeq};
use hash;
use ringbuf::RingBuf;
use string::String;

3
src/libcollections/string.rs
View File

@ -20,9 +20,8 @@ use core::mem;
use core::ptr;
// FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
use RawSlice = core::raw::Slice;
use core::slice::Slice;
use {Collection, Mutable, MutableSeq};
use {Mutable, MutableSeq};
use hash;
use str;
use str::{CharRange, StrAllocating, MaybeOwned, Owned};

2
src/libcollections/treemap.rs
View File

@ -40,7 +40,7 @@ use core::mem::{replace, swap};
use core::ptr;
use std::hash::{Writer, Hash};
use {Collection, Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
use {Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
use vec::Vec;
/// This is implemented as an AA tree, which is a simplified variation of

2
src/libcollections/trie.rs
View File

@ -23,7 +23,7 @@ use core::uint;
use core::iter;
use std::hash::{Writer, Hash};
use {Collection, Mutable, Map, MutableMap, Set, MutableSet};
use {Mutable, Map, MutableMap, Set, MutableSet};
use slice::{Items, MutItems};
use slice;

4
src/libcollections/vec.rs
View File

@ -14,17 +14,15 @@ use core::prelude::*;
use alloc::heap::{allocate, reallocate, deallocate};
use RawSlice = core::raw::Slice;
use core::slice::Slice;
use core::cmp::max;
use core::default::Default;
use core::fmt;
use core::mem;
use core::num::{CheckedMul, CheckedAdd};
use core::num;
use core::ptr;
use core::uint;
use {Collection, Mutable, MutableSeq};
use {Mutable, MutableSeq};
use slice::{MutableOrdSlice, MutableSliceAllocating, CloneableVector};
use slice::{Items, MutItems};

19
src/libcore/fmt/mod.rs
View File

@ -14,12 +14,10 @@
use any;
use cell::{Cell, Ref, RefMut};
use char::Char;
use collections::Collection;
use iter::{Iterator, range};
use kinds::Copy;
use mem;
use num::Float;
use option::{Option, Some, None};
use ops::Deref;
use result::{Ok, Err};
@ -342,8 +340,12 @@ impl<'a> Formatter<'a> {
///
/// This function will correctly account for the flags provided as well as
/// the minimum width. It will not take precision into account.
pub fn pad_integral(&mut self, is_positive: bool, prefix: &str,
buf: &[u8]) -> Result {
pub fn pad_integral(&mut self,
is_positive: bool,
prefix: &str,
buf: &[u8])
-> Result {
use char::Char;
use fmt::rt::{FlagAlternate, FlagSignPlus, FlagSignAwareZeroPad};
let mut width = buf.len();
@ -456,6 +458,7 @@ impl<'a> Formatter<'a> {
padding: uint,
default: rt::Alignment,
f: |&mut Formatter| -> Result) -> Result {
use char::Char;
let align = match self.align {
rt::AlignUnknown => default,
rt::AlignLeft | rt::AlignRight => self.align
@ -539,6 +542,8 @@ impl<'a, T: str::Str> String for T {
impl Char for char {
fn fmt(&self, f: &mut Formatter) -> Result {
use char::Char;
let mut utf8 = [0u8, ..4];
let amt = self.encode_utf8(utf8);
let s: &str = unsafe { mem::transmute(utf8.slice_to(amt)) };
@ -571,7 +576,7 @@ impl<'a, T> Pointer for &'a mut T {
macro_rules! floating(($ty:ident) => {
impl Float for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Signed;
use num::{Float, Signed};
let digits = match fmt.precision {
Some(i) => float::DigExact(i),
@ -592,7 +597,7 @@ macro_rules! floating(($ty:ident) => {
impl LowerExp for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Signed;
use num::{Float, Signed};
let digits = match fmt.precision {
Some(i) => float::DigExact(i),
@ -613,7 +618,7 @@ macro_rules! floating(($ty:ident) => {
impl UpperExp for $ty {
fn fmt(&self, fmt: &mut Formatter) -> Result {
use num::Signed;
use num::{Float, Signed};
let digits = match fmt.precision {
Some(i) => float::DigExact(i),

5
src/libfmt_macros/lib.rs
View File

@ -19,7 +19,10 @@
#![license = "MIT/ASL2"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
#![feature(macro_rules, globs)]
#![feature(macro_rules, globs, import_shadowing)]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
use std::char;
use std::str;

4
src/libgetopts/lib.rs
View File

@ -88,8 +88,12 @@
html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")]
#![feature(globs, phase)]
#![feature(import_shadowing)]
#![deny(missing_doc)]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[cfg(test)] extern crate debug;
#[cfg(test)] #[phase(plugin, link)] extern crate log;

6
src/liblibc/lib.rs
View File

@ -226,7 +226,7 @@ pub use funcs::bsd43::{shutdown};
#[cfg(windows)] pub use consts::os::extra::{FILE_FLAG_BACKUP_SEMANTICS, INVALID_HANDLE_VALUE};
#[cfg(windows)] pub use consts::os::extra::{MOVEFILE_REPLACE_EXISTING};
#[cfg(windows)] pub use consts::os::extra::{GENERIC_READ, GENERIC_WRITE};
#[cfg(windows)] pub use consts::os::extra::{VOLUME_NAME_DOS, FILE_ATTRIBUTE_NORMAL};
#[cfg(windows)] pub use consts::os::extra::{VOLUME_NAME_DOS};
#[cfg(windows)] pub use consts::os::extra::{PIPE_ACCESS_DUPLEX, FILE_FLAG_FIRST_PIPE_INSTANCE};
#[cfg(windows)] pub use consts::os::extra::{FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE};
#[cfg(windows)] pub use consts::os::extra::{PIPE_READMODE_BYTE, PIPE_WAIT};
@ -255,10 +255,10 @@ pub use funcs::bsd43::{shutdown};
#[cfg(windows)] pub use funcs::extra::kernel32::{UnmapViewOfFile, CloseHandle};
#[cfg(windows)] pub use funcs::extra::kernel32::{WaitForSingleObject, GetSystemTimeAsFileTime};
#[cfg(windows)] pub use funcs::extra::kernel32::{QueryPerformanceCounter};
#[cfg(windows)] pub use funcs::extra::kernel32::{WaitForSingleObject, QueryPerformanceFrequency};
#[cfg(windows)] pub use funcs::extra::kernel32::{QueryPerformanceFrequency};
#[cfg(windows)] pub use funcs::extra::kernel32::{GetExitCodeProcess, TerminateProcess};
#[cfg(windows)] pub use funcs::extra::kernel32::{ReadFile, WriteFile, SetFilePointerEx};
#[cfg(windows)] pub use funcs::extra::kernel32::{FlushFileBuffers, SetEndOfFile, CreateFileW};
#[cfg(windows)] pub use funcs::extra::kernel32::{SetEndOfFile, CreateFileW};
#[cfg(windows)] pub use funcs::extra::kernel32::{CreateDirectoryW, FindFirstFileW};
#[cfg(windows)] pub use funcs::extra::kernel32::{FindNextFileW, FindClose, DeleteFileW};
#[cfg(windows)] pub use funcs::extra::kernel32::{CreateHardLinkW, CreateEventW};

1
src/librand/distributions/mod.rs
View File

@ -24,7 +24,6 @@ that do not need to record state.
use core::prelude::*;
use core::num;
use core::num::CheckedAdd;
use {Rng, Rand};

3
src/librand/distributions/range.rs
View File

@ -35,12 +35,11 @@ use distributions::{Sample, IndependentSample};
/// # Example
///
/// ```rust
/// use std::rand;
/// use std::rand::distributions::{IndependentSample, Range};
///
/// fn main() {
/// let between = Range::new(10u, 10000u);
/// let mut rng = rand::task_rng();
/// let mut rng = std::rand::task_rng();
/// let mut sum = 0;
/// for _ in range(0u, 1000) {
/// sum += between.ind_sample(&mut rng);

5
src/librlibc/lib.rs
View File

@ -28,13 +28,16 @@
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/")]
#![feature(intrinsics, phase)]
#![feature(import_shadowing, intrinsics, phase)]
#![no_std]
// This library defines the builtin functions, so it would be a shame for
// LLVM to optimize these function calls to themselves!
#![no_builtins]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[cfg(test)] extern crate native;
#[cfg(test)] extern crate test;
#[cfg(test)] extern crate debug;

9
src/librustc/front/feature_gate.rs
View File

@ -68,6 +68,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
("rustc_diagnostic_macros", Active),
("unboxed_closures", Active),
("import_shadowing", Active),
// if you change this list without updating src/doc/rust.md, cmr will be sad
@ -98,7 +99,8 @@ pub struct Features {
pub default_type_params: Cell<bool>,
pub issue_5723_bootstrap: Cell<bool>,
pub overloaded_calls: Cell<bool>,
pub rustc_diagnostic_macros: Cell<bool>
pub rustc_diagnostic_macros: Cell<bool>,
pub import_shadowing: Cell<bool>,
}
impl Features {
@ -107,7 +109,8 @@ impl Features {
default_type_params: Cell::new(false),
issue_5723_bootstrap: Cell::new(false),
overloaded_calls: Cell::new(false),
rustc_diagnostic_macros: Cell::new(false)
rustc_diagnostic_macros: Cell::new(false),
import_shadowing: Cell::new(false),
}
}
}
@ -439,4 +442,6 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
sess.features.issue_5723_bootstrap.set(cx.has_feature("issue_5723_bootstrap"));
sess.features.overloaded_calls.set(cx.has_feature("overloaded_calls"));
sess.features.rustc_diagnostic_macros.set(cx.has_feature("rustc_diagnostic_macros"));
sess.features.import_shadowing.set(cx.has_feature("import_shadowing"));
}

15
src/librustc/front/std_inject.rs
View File

@ -19,6 +19,7 @@ use syntax::fold::Folder;
use syntax::fold;
use syntax::owned_slice::OwnedSlice;
use syntax::parse::token::InternedString;
use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::util::small_vector::SmallVector;
@ -197,7 +198,19 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
ast::DUMMY_NODE_ID));
let vi2 = ast::ViewItem {
node: ast::ViewItemUse(vp),
attrs: Vec::new(),
attrs: vec!(ast::Attribute {
span: DUMMY_SP,
node: ast::Attribute_ {
id: attr::mk_attr_id(),
style: ast::AttrOuter,
value: box(GC) ast::MetaItem {
span: DUMMY_SP,
node: ast::MetaWord(token::get_name(
special_idents::prelude_import.name)),
},
is_sugared_doc: false,
},
}),
vis: ast::Inherited,
span: DUMMY_SP,
};

1
src/librustc/lib.rs
View File

@ -34,6 +34,7 @@ This API is completely unstable and subject to change.
#![allow(unknown_features)] // NOTE: Remove after next snapshot
#![feature(rustc_diagnostic_macros)]
#![feature(import_shadowing)]
extern crate arena;
extern crate debug;

3
src/librustc/lint/builtin.rs
View File

@ -581,6 +581,9 @@ impl LintPass for UnusedAttribute {
"thread_local",
"no_debug",
// used in resolve
"prelude_import",
// not used anywhere (!?) but apparently we want to keep them around
"comment",
"desc",

1
src/librustc/metadata/encoder.rs
View File

@ -42,7 +42,6 @@ use syntax::ast_map::{PathElem, PathElems};
use syntax::ast_map;
use syntax::ast_util::*;
use syntax::ast_util;
use syntax::ast_util::PostExpansionMethod;
use syntax::attr;
use syntax::attr::AttrMetaMethods;
use syntax::diagnostic::SpanHandler;

16
src/librustc/middle/astencode.rs
View File

@ -47,8 +47,8 @@ use rbml::io::SeekableMemWriter;
use rbml::{reader, writer};
use rbml;
use serialize;
use serialize::{Encoder, Encodable, EncoderHelpers, DecoderHelpers};
use serialize::{Decoder, Decodable};
use serialize::{Decodable, Decoder, DecoderHelpers, Encodable};
use serialize::{EncoderHelpers};
#[cfg(test)] use syntax::parse;
#[cfg(test)] use syntax::print::pprust;
@ -620,6 +620,8 @@ fn encode_method_callee(ecx: &e::EncodeContext,
rbml_w: &mut Encoder,
adjustment: typeck::ExprAdjustment,
method: &MethodCallee) {
use serialize::Encoder;
rbml_w.emit_struct("MethodCallee", 4, |rbml_w| {
rbml_w.emit_struct_field("adjustment", 0u, |rbml_w| {
adjustment.encode(rbml_w)
@ -695,6 +697,8 @@ fn encode_vtable_res_with_key(ecx: &e::EncodeContext,
rbml_w: &mut Encoder,
adjustment: typeck::ExprAdjustment,
dr: &typeck::vtable_res) {
use serialize::Encoder;
rbml_w.emit_struct("VtableWithKey", 2, |rbml_w| {
rbml_w.emit_struct_field("adjustment", 0u, |rbml_w| {
adjustment.encode(rbml_w)
@ -728,6 +732,8 @@ pub fn encode_vtable_param_res(ecx: &e::EncodeContext,
pub fn encode_unboxed_closure_kind(ebml_w: &mut Encoder,
kind: ty::UnboxedClosureKind) {
use serialize::Encoder;
ebml_w.emit_enum("UnboxedClosureKind", |ebml_w| {
match kind {
ty::FnUnboxedClosureKind => {
@ -755,6 +761,8 @@ pub fn encode_unboxed_closure_kind(ebml_w: &mut Encoder,
pub fn encode_vtable_origin(ecx: &e::EncodeContext,
rbml_w: &mut Encoder,
vtable_origin: &typeck::vtable_origin) {
use serialize::Encoder;
rbml_w.emit_enum("vtable_origin", |rbml_w| {
match *vtable_origin {
typeck::vtable_static(def_id, ref substs, ref vtable_res) => {
@ -985,6 +993,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
fn emit_polytype(&mut self,
ecx: &e::EncodeContext,
pty: ty::Polytype) {
use serialize::Encoder;
self.emit_struct("Polytype", 2, |this| {
this.emit_struct_field("generics", 0, |this| {
this.emit_struct("Generics", 2, |this| {
@ -1013,6 +1023,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
}
fn emit_auto_adjustment(&mut self, ecx: &e::EncodeContext, adj: &ty::AutoAdjustment) {
use serialize::Encoder;
self.emit_enum("AutoAdjustment", |this| {
match *adj {
ty::AutoAddEnv(store) => {

317
src/librustc/middle/resolve.rs
View File

@ -21,10 +21,31 @@ use middle::subst::{ParamSpace, FnSpace, TypeSpace};
use middle::ty::{ExplicitSelfCategory, StaticExplicitSelfCategory};
use util::nodemap::{NodeMap, DefIdSet, FnvHashMap};
use syntax::ast::*;
use syntax::ast::{Arm, BindByRef, BindByValue, BindingMode, Block, Crate};
use syntax::ast::{DeclItem, DefId, Expr, ExprAgain, ExprBreak, ExprField};
use syntax::ast::{ExprFnBlock, ExprForLoop, ExprLoop, ExprMethodCall};
use syntax::ast::{ExprPath, ExprProc, ExprStruct, ExprUnboxedFn, FnDecl};
use syntax::ast::{ForeignItem, ForeignItemFn, ForeignItemStatic, Generics};
use syntax::ast::{Ident, ImplItem, Item, ItemEnum, ItemFn, ItemForeignMod};
use syntax::ast::{ItemImpl, ItemMac, ItemMod, ItemStatic, ItemStruct};
use syntax::ast::{ItemTrait, ItemTy, LOCAL_CRATE, Local, Method};
use syntax::ast::{MethodImplItem, Mod, Name, NamedField, NodeId};
use syntax::ast::{OtherRegionTyParamBound, P, Pat, PatEnum, PatIdent, PatLit};
use syntax::ast::{PatRange, PatStruct, Path, PathListIdent, PathListMod};
use syntax::ast::{PrimTy, Public, SelfExplicit, SelfStatic};
use syntax::ast::{StaticRegionTyParamBound, StmtDecl, StructField};
use syntax::ast::{StructVariantKind, TraitRef, TraitTyParamBound};
use syntax::ast::{TupleVariantKind, Ty, TyBool, TyChar, TyClosure, TyF32};
use syntax::ast::{TyF64, TyFloat, TyI, TyI8, TyI16, TyI32, TyI64, TyInt};
use syntax::ast::{TyParam, TyParamBound, TyPath, TyPtr, TyProc, TyRptr};
use syntax::ast::{TyStr, TyU, TyU8, TyU16, TyU32, TyU64, TyUint};
use syntax::ast::{UnboxedFnTyParamBound, UnnamedField, UnsafeFn, Variant};
use syntax::ast::{ViewItem, ViewItemExternCrate, ViewItemUse, ViewPathGlob};
use syntax::ast::{ViewPathList, ViewPathSimple, Visibility};
use syntax::ast;
use syntax::ast_util::{local_def, PostExpansionMethod};
use syntax::ast_util::{walk_pat, trait_item_to_ty_method};
use syntax::ast_util::{PostExpansionMethod, local_def};
use syntax::ast_util::{trait_item_to_ty_method, walk_pat};
use syntax::attr::AttrMetaMethods;
use syntax::ext::mtwt;
use syntax::parse::token::special_names;
use syntax::parse::token::special_idents;
@ -355,6 +376,7 @@ struct ImportDirective {
span: Span,
id: NodeId,
is_public: bool, // see note in ImportResolution about how to use this
shadowable: bool,
}
impl ImportDirective {
@ -362,7 +384,8 @@ impl ImportDirective {
subclass: ImportDirectiveSubclass,
span: Span,
id: NodeId,
is_public: bool)
is_public: bool,
shadowable: bool)
-> ImportDirective {
ImportDirective {
module_path: module_path,
@ -370,6 +393,7 @@ impl ImportDirective {
span: span,
id: id,
is_public: is_public,
shadowable: shadowable,
}
}
}
@ -379,13 +403,18 @@ impl ImportDirective {
struct Target {
target_module: Rc<Module>,
bindings: Rc<NameBindings>,
shadowable: bool,
}
impl Target {
fn new(target_module: Rc<Module>, bindings: Rc<NameBindings>) -> Target {
fn new(target_module: Rc<Module>,
bindings: Rc<NameBindings>,
shadowable: bool)
-> Target {
Target {
target_module: target_module,
bindings: bindings
bindings: bindings,
shadowable: shadowable,
}
}
}
@ -1018,6 +1047,10 @@ impl<'a> Resolver<'a> {
let module_ = reduced_graph_parent.module();
self.check_for_conflicts_between_external_crates_and_items(&*module_,
name.name,
sp);
// Add or reuse the child.
let child = module_.children.borrow().find_copy(&name.name);
match child {
@ -1481,6 +1514,14 @@ impl<'a> Resolver<'a> {
// Build up the import directives.
let module_ = parent.module();
let is_public = view_item.vis == ast::Public;
let shadowable =
view_item.attrs
.iter()
.any(|attr| {
attr.name() == token::get_ident(
special_idents::prelude_import)
});
match view_path.node {
ViewPathSimple(binding, ref full_path, id) => {
let source_ident =
@ -1497,7 +1538,8 @@ impl<'a> Resolver<'a> {
subclass,
view_path.span,
id,
is_public);
is_public,
shadowable);
}
ViewPathList(_, ref source_items, _) => {
// Make sure there's at most one `mod` import in the list.
@ -1542,7 +1584,9 @@ impl<'a> Resolver<'a> {
module_path,
SingleImport(name, name),
source_item.span,
source_item.node.id(), is_public);
source_item.node.id(),
is_public,
shadowable);
}
}
ViewPathGlob(_, id) => {
@ -1551,7 +1595,8 @@ impl<'a> Resolver<'a> {
GlobImport,
view_path.span,
id,
is_public);
is_public,
shadowable);
}
}
}
@ -1571,6 +1616,10 @@ impl<'a> Resolver<'a> {
true));
debug!("(build reduced graph for item) found extern `{}`",
self.module_to_string(&*external_module));
self.check_for_conflicts_between_external_crates(
&*parent.module(),
name.name,
view_item.span);
parent.module().external_module_children.borrow_mut()
.insert(name.name, external_module.clone());
self.build_reduced_graph_for_external_crate(external_module);
@ -1989,11 +2038,14 @@ impl<'a> Resolver<'a> {
subclass: ImportDirectiveSubclass,
span: Span,
id: NodeId,
is_public: bool) {
is_public: bool,
shadowable: bool) {
module_.imports.borrow_mut().push(ImportDirective::new(module_path,
subclass,
span, id,
is_public));
span,
id,
is_public,
shadowable));
self.unresolved_imports += 1;
// Bump the reference count on the name. Or, if this is a glob, set
// the appropriate flag.
@ -2241,8 +2293,7 @@ impl<'a> Resolver<'a> {
resolution_result =
self.resolve_glob_import(&*module_,
containing_module,
import_directive.id,
import_directive.is_public,
import_directive,
lp);
}
}
@ -2397,7 +2448,11 @@ impl<'a> Resolver<'a> {
None => {
return UnboundResult;
}
Some(Target {target_module, bindings}) => {
Some(Target {
target_module,
bindings,
shadowable: _
}) => {
debug!("(resolving single import) found \
import in ns {:?}", namespace);
let id = import_resolution.id(namespace);
@ -2462,8 +2517,16 @@ impl<'a> Resolver<'a> {
match value_result {
BoundResult(ref target_module, ref name_bindings) => {
debug!("(resolving single import) found value target");
import_resolution.value_target = Some(Target::new(target_module.clone(),
name_bindings.clone()));
self.check_for_conflicting_import(
&import_resolution.value_target,
directive.span,
target.name,
ValueNS);
import_resolution.value_target =
Some(Target::new(target_module.clone(),
name_bindings.clone(),
directive.shadowable));
import_resolution.value_id = directive.id;
import_resolution.is_public = directive.is_public;
value_used_public = name_bindings.defined_in_public_namespace(ValueNS);
@ -2477,8 +2540,16 @@ impl<'a> Resolver<'a> {
BoundResult(ref target_module, ref name_bindings) => {
debug!("(resolving single import) found type target: {:?}",
{ name_bindings.type_def.borrow().clone().unwrap().type_def });
self.check_for_conflicting_import(
&import_resolution.type_target,
directive.span,
target.name,
TypeNS);
import_resolution.type_target =
Some(Target::new(target_module.clone(), name_bindings.clone()));
Some(Target::new(target_module.clone(),
name_bindings.clone(),
directive.shadowable));
import_resolution.type_id = directive.id;
import_resolution.is_public = directive.is_public;
type_used_public = name_bindings.defined_in_public_namespace(TypeNS);
@ -2489,6 +2560,12 @@ impl<'a> Resolver<'a> {
}
}
self.check_for_conflicts_between_imports_and_items(
module_,
import_resolution,
directive.span,
target.name);
if value_result.is_unbound() && type_result.is_unbound() {
let msg = format!("There is no `{}` in `{}`",
token::get_ident(source),
@ -2540,10 +2617,12 @@ impl<'a> Resolver<'a> {
fn resolve_glob_import(&mut self,
module_: &Module,
containing_module: Rc<Module>,
id: NodeId,
is_public: bool,
import_directive: &ImportDirective,
lp: LastPrivate)
-> ResolveResult<()> {
let id = import_directive.id;
let is_public = import_directive.is_public;
// This function works in a highly imperative manner; it eagerly adds
// everything it can to the list of import resolutions of the module
// node.
@ -2619,9 +2698,12 @@ impl<'a> Resolver<'a> {
for (&name, name_bindings) in containing_module.children
.borrow().iter() {
self.merge_import_resolution(module_, containing_module.clone(),
id, is_public,
name, name_bindings.clone());
self.merge_import_resolution(module_,
containing_module.clone(),
import_directive,
name,
name_bindings.clone());
}
// Add external module children from the containing module.
@ -2629,9 +2711,11 @@ impl<'a> Resolver<'a> {
.borrow().iter() {
let name_bindings =
Rc::new(Resolver::create_name_bindings_from_module(module.clone()));
self.merge_import_resolution(module_, containing_module.clone(),
id, is_public,
name, name_bindings);
self.merge_import_resolution(module_,
containing_module.clone(),
import_directive,
name,
name_bindings);
}
// Record the destination of this import
@ -2650,10 +2734,12 @@ impl<'a> Resolver<'a> {
fn merge_import_resolution(&mut self,
module_: &Module,
containing_module: Rc<Module>,
id: NodeId,
is_public: bool,
import_directive: &ImportDirective,
name: Name,
name_bindings: Rc<NameBindings>) {
let id = import_directive.id;
let is_public = import_directive.is_public;
let mut import_resolutions = module_.import_resolutions.borrow_mut();
let dest_import_resolution = import_resolutions.find_or_insert_with(name, |_| {
// Create a new import resolution from this child.
@ -2670,16 +2756,169 @@ impl<'a> Resolver<'a> {
if name_bindings.defined_in_public_namespace(ValueNS) {
debug!("(resolving glob import) ... for value target");
dest_import_resolution.value_target =
Some(Target::new(containing_module.clone(), name_bindings.clone()));
Some(Target::new(containing_module.clone(),
name_bindings.clone(),
import_directive.shadowable));
dest_import_resolution.value_id = id;
}
if name_bindings.defined_in_public_namespace(TypeNS) {
debug!("(resolving glob import) ... for type target");
dest_import_resolution.type_target =
Some(Target::new(containing_module, name_bindings.clone()));
Some(Target::new(containing_module,
name_bindings.clone(),
import_directive.shadowable));
dest_import_resolution.type_id = id;
}
dest_import_resolution.is_public = is_public;
self.check_for_conflicts_between_imports_and_items(
module_,
dest_import_resolution,
import_directive.span,
name);
}
/// Checks that imported names and items don't have the same name.
fn check_for_conflicting_import(&mut self,
target: &Option<Target>,
import_span: Span,
name: Name,
namespace: Namespace) {
if self.session.features.import_shadowing.get() {
return
}
match *target {
Some(ref target) if !target.shadowable => {
let msg = format!("a {} named `{}` has already been imported \
in this module",
match namespace {
TypeNS => "type",
ValueNS => "value",
},
token::get_name(name).get());
self.session.span_err(import_span, msg.as_slice());
}
Some(_) | None => {}
}
}
/// Checks that imported names and items don't have the same name.
fn check_for_conflicts_between_imports_and_items(&mut self,
module: &Module,
import_resolution:
&mut ImportResolution,
import_span: Span,
name: Name) {
if self.session.features.import_shadowing.get() {
return
}
// First, check for conflicts between imports and `extern crate`s.
if module.external_module_children
.borrow()
.contains_key(&name) {
match import_resolution.type_target {
Some(ref target) if !target.shadowable => {
self.session.span_err(import_span,
"import conflicts with imported \
crate in this module");
}
Some(_) | None => {}
}
}
// Check for item conflicts.
let children = module.children.borrow();
let name_bindings = match children.find(&name) {
None => {
// There can't be any conflicts.
return
}
Some(ref name_bindings) => (*name_bindings).clone(),
};
match import_resolution.value_target {
Some(ref target) if !target.shadowable => {
match *name_bindings.value_def.borrow() {
None => {}
Some(ref value) => {
self.session.span_err(import_span,
"import conflicts with value \
in this module");
match value.value_span {
None => {}
Some(span) => {
self.session
.span_note(span,
"note conflicting value here");
}
}
}
}
}
Some(_) | None => {}
}
match import_resolution.type_target {
Some(ref target) if !target.shadowable => {
match *name_bindings.type_def.borrow() {
None => {}
Some(ref ty) => {
self.session.span_err(import_span,
"import conflicts with type in \
this module");
match ty.type_span {
None => {}
Some(span) => {
self.session
.span_note(span,
"note conflicting type here")
}
}
}
}
}
Some(_) | None => {}
}
}
/// Checks that the names of external crates don't collide with other
/// external crates.
fn check_for_conflicts_between_external_crates(&self,
module: &Module,
name: Name,
span: Span) {
if self.session.features.import_shadowing.get() {
return
}
if module.external_module_children.borrow().contains_key(&name) {
self.session
.span_err(span,
format!("an external crate named `{}` has already \
been imported into this module",
token::get_name(name).get()).as_slice());
}
}
/// Checks that the names of items don't collide with external crates.
fn check_for_conflicts_between_external_crates_and_items(&self,
module: &Module,
name: Name,
span: Span) {
if self.session.features.import_shadowing.get() {
return
}
if module.external_module_children.borrow().contains_key(&name) {
self.session
.span_err(span,
format!("the name `{}` conflicts with an external \
crate that has been imported into this \
module",
token::get_name(name).get()).as_slice());
}
}
/// Resolves the given module path from the given root `module_`.
@ -2947,7 +3186,9 @@ impl<'a> Resolver<'a> {
Some(name_bindings)
if name_bindings.defined_in_namespace(namespace) => {
debug!("top name bindings succeeded");
return Success((Target::new(module_.clone(), name_bindings.clone()),
return Success((Target::new(module_.clone(),
name_bindings.clone(),
false),
false));
}
Some(_) | None => { /* Not found; continue. */ }
@ -2987,7 +3228,10 @@ impl<'a> Resolver<'a> {
let name_bindings =
Rc::new(Resolver::create_name_bindings_from_module(module));
debug!("lower name bindings succeeded");
return Success((Target::new(module_, name_bindings), false));
return Success((Target::new(module_,
name_bindings,
false),
false));
}
}
}
@ -3210,7 +3454,9 @@ impl<'a> Resolver<'a> {
Some(name_bindings)
if name_bindings.defined_in_namespace(namespace) => {
debug!("(resolving name in module) found node as child");
return Success((Target::new(module_.clone(), name_bindings.clone()),
return Success((Target::new(module_.clone(),
name_bindings.clone(),
false),
false));
}
Some(_) | None => {
@ -3261,7 +3507,10 @@ impl<'a> Resolver<'a> {
Some(module) => {
let name_bindings =
Rc::new(Resolver::create_name_bindings_from_module(module));
return Success((Target::new(module_, name_bindings), false));
return Success((Target::new(module_,
name_bindings,
false),
false));
}
}
}

3
src/librustc/middle/trans/_match.rs
View File

@ -203,7 +203,8 @@ use middle::pat_util::*;
use middle::resolve::DefMap;
use middle::trans::adt;
use middle::trans::base::*;
use middle::trans::build::*;
use middle::trans::build::{And, BitCast, Br, CondBr, GEPi, InBoundsGEP, Load};
use middle::trans::build::{Mul, Not, Store, Sub, Switch, add_comment};
use middle::trans::build;
use middle::trans::callee;
use middle::trans::cleanup;

12
src/librustc/middle/trans/base.rs
View File

@ -47,11 +47,17 @@ use middle::trans::builder::{Builder, noname};
use middle::trans::callee;
use middle::trans::cleanup::{CleanupMethods, ScopeId};
use middle::trans::cleanup;
use middle::trans::common::*;
use middle::trans::common::{Block, C_bool, C_bytes, C_i32, C_integral, C_nil};
use middle::trans::common::{C_null, C_struct, C_u64, C_u8, C_uint, C_undef};
use middle::trans::common::{CrateContext, ExternMap, FunctionContext};
use middle::trans::common::{NodeInfo, Result, SubstP, monomorphize_type};
use middle::trans::common::{node_id_type, param_substs, return_type_is_void};
use middle::trans::common::{tydesc_info, type_is_immediate};
use middle::trans::common::{type_is_zero_size, val_ty};
use middle::trans::common;
use middle::trans::consts;
use middle::trans::controlflow;
use middle::trans::datum;
// use middle::trans::datum::{Datum, Lvalue, Rvalue, ByRef, ByValue};
use middle::trans::debuginfo;
use middle::trans::expr;
use middle::trans::foreign;
@ -1074,7 +1080,7 @@ pub fn raw_block<'a>(
is_lpad: bool,
llbb: BasicBlockRef)
-> &'a Block<'a> {
Block::new(llbb, is_lpad, None, fcx)
common::Block::new(llbb, is_lpad, None, fcx)
}
pub fn with_cond<'a>(

2
src/librustc/middle/trans/cabi_mips.rs
View File

@ -15,8 +15,8 @@ use std::cmp;
use llvm;
use llvm::{Integer, Pointer, Float, Double, Struct, Array};
use llvm::{StructRetAttribute, ZExtAttribute};
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::context::CrateContext;
use middle::trans::cabi::*;
use middle::trans::type_::Type;
fn align_up_to(off: uint, a: uint) -> uint {

7
src/librustc/middle/trans/cabi_x86.rs
View File

@ -8,13 +8,12 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use syntax::abi::{OsWindows, OsMacos, OsiOS};
use llvm::*;
use super::cabi::*;
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::type_::Type;
use super::common::*;
use super::machine::*;
use middle::trans::type_::Type;
use syntax::abi::{OsWindows, OsMacos, OsiOS};
pub fn compute_abi_info(ccx: &CrateContext,
atys: &[Type],

2
src/librustc/middle/trans/cabi_x86_64.rs
View File

@ -17,7 +17,7 @@ use llvm;
use llvm::{Integer, Pointer, Float, Double};
use llvm::{Struct, Array, Attribute};
use llvm::{StructRetAttribute, ByValAttribute, ZExtAttribute};
use middle::trans::cabi::*;
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::context::CrateContext;
use middle::trans::type_::Type;

2
src/librustc/middle/trans/cabi_x86_win64.rs
View File

@ -9,9 +9,9 @@
// except according to those terms.
use llvm::*;
use super::cabi::*;
use super::common::*;
use super::machine::*;
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::type_::Type;
// Win64 ABI: http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx

1
src/librustc/middle/trans/callee.rs
View File

@ -37,7 +37,6 @@ use middle::trans::closure;
use middle::trans::common;
use middle::trans::common::*;
use middle::trans::datum::*;
use middle::trans::datum::{Datum, KindOps};
use middle::trans::expr;
use middle::trans::glue;
use middle::trans::inline;

13
src/librustc/middle/trans/controlflow.rs
View File

@ -22,10 +22,10 @@ use middle::trans::cleanup;
use middle::trans::common::*;
use middle::trans::consts;
use middle::trans::datum;
use middle::trans::debuginfo;
use middle::trans::expr;
use middle::trans::meth;
use middle::trans::type_::Type;
use middle::trans;
use middle::ty;
use middle::typeck::MethodCall;
use util::ppaux::Repr;
@ -66,7 +66,8 @@ pub fn trans_stmt<'a>(cx: &'a Block<'a>,
ast::DeclLocal(ref local) => {
bcx = init_local(bcx, &**local);
if cx.sess().opts.debuginfo == FullDebugInfo {
debuginfo::create_local_var_metadata(bcx, &**local);
trans::debuginfo::create_local_var_metadata(bcx,
&**local);
}
}
// Inner items are visited by `trans_item`/`trans_meth`.
@ -154,7 +155,7 @@ pub fn trans_if<'a>(bcx: &'a Block<'a>,
}
// if true { .. } [else { .. }]
bcx = trans_block(bcx, &*thn, dest);
debuginfo::clear_source_location(bcx.fcx);
trans::debuginfo::clear_source_location(bcx.fcx);
} else {
let mut trans = TransItemVisitor { ccx: bcx.fcx.ccx } ;
trans.visit_block(&*thn, ());
@ -163,7 +164,7 @@ pub fn trans_if<'a>(bcx: &'a Block<'a>,
// if false { .. } else { .. }
Some(elexpr) => {
bcx = expr::trans_into(bcx, &*elexpr, dest);
debuginfo::clear_source_location(bcx.fcx);
trans::debuginfo::clear_source_location(bcx.fcx);
}
// if false { .. }
@ -177,7 +178,7 @@ pub fn trans_if<'a>(bcx: &'a Block<'a>,
let name = format!("then-block-{}-", thn.id);
let then_bcx_in = bcx.fcx.new_id_block(name.as_slice(), thn.id);
let then_bcx_out = trans_block(then_bcx_in, &*thn, dest);
debuginfo::clear_source_location(bcx.fcx);
trans::debuginfo::clear_source_location(bcx.fcx);
let next_bcx;
match els {
@ -198,7 +199,7 @@ pub fn trans_if<'a>(bcx: &'a Block<'a>,
// Clear the source location because it is still set to whatever has been translated
// right before.
debuginfo::clear_source_location(next_bcx.fcx);
trans::debuginfo::clear_source_location(next_bcx.fcx);
next_bcx
}

5
src/librustc/middle/ty.rs
View File

@ -51,7 +51,10 @@ use std::ops;
use std::rc::Rc;
use std::collections::{HashMap, HashSet};
use syntax::abi;
use syntax::ast::*;
use syntax::ast::{CrateNum, DefId, FnStyle, Ident, ItemTrait, LOCAL_CRATE};
use syntax::ast::{MutImmutable, MutMutable, Name, NamedField, NodeId};
use syntax::ast::{Onceness, StmtExpr, StmtSemi, StructField, UnnamedField};
use syntax::ast::{Visibility};
use syntax::ast_util::{is_local, lit_is_str};
use syntax::ast_util;
use syntax::attr;

5
src/librustrt/c_str.rs
View File

@ -65,14 +65,15 @@ fn main() {
*/
use core::prelude::*;
use alloc::libc_heap::malloc_raw;
use collections::string::String;
use collections::hash;
use core::fmt;
use core::kinds::marker;
use core::mem;
use core::prelude::{Clone, Collection, Drop, Eq, ImmutableSlice, Iterator};
use core::prelude::{MutableSlice, None, Option, Ordering, PartialEq};
use core::prelude::{PartialOrd, RawPtr, Some, StrSlice, range};
use core::ptr;
use core::raw::Slice;
use core::slice;

4
src/librustrt/lib.rs
View File

@ -18,9 +18,13 @@
#![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
#![feature(linkage, lang_items, unsafe_destructor, default_type_params)]
#![feature(import_shadowing)]
#![no_std]
#![experimental]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[phase(plugin, link)] extern crate core;
extern crate alloc;
extern crate libc;

4
src/librustrt/local_data.rs
View File

@ -42,7 +42,7 @@ use core::prelude::*;
use alloc::heap;
use collections::treemap::TreeMap;
use collections::{Map, MutableMap};
use collections::MutableMap;
use core::cmp;
use core::kinds::marker;
use core::mem;
@ -261,6 +261,8 @@ impl<T: 'static> KeyValue<T> {
/// assert_eq!(*key.get().unwrap(), 3);
/// ```
pub fn get(&'static self) -> Option<Ref<T>> {
use collections::Map;
let map = match unsafe { get_local_map() } {
Some(map) => map,
None => return None,

4
src/librustrt/task.rs
View File

@ -13,8 +13,6 @@
//! local storage, and logging. Even a 'freestanding' Rust would likely want
//! to implement this.
use core::prelude::*;
use alloc::arc::Arc;
use alloc::boxed::{BoxAny, Box};
use core::any::Any;
@ -22,6 +20,8 @@ use core::atomic::{AtomicUint, SeqCst};
use core::iter::Take;
use core::kinds::marker;
use core::mem;
use core::prelude::{Clone, Drop, Err, Iterator, None, Ok, Option, Send, Some};
use core::prelude::{drop};
use core::raw;
use local_data;

2
src/librustrt/unwind.rs
View File

@ -72,7 +72,7 @@ use core::raw::Closure;
use libc::c_void;
use local::Local;
use task::{Task, Result};
use task::Task;
use uw = libunwind;

2
src/libstd/fmt.rs
View File

@ -437,8 +437,6 @@ pub use core::fmt::{secret_signed, secret_lower_hex, secret_upper_hex};
#[doc(hidden)]
pub use core::fmt::{secret_bool, secret_char, secret_octal, secret_binary};
#[doc(hidden)]
pub use core::fmt::{secret_bool, secret_char, secret_octal, secret_binary};
#[doc(hidden)]
pub use core::fmt::{secret_float, secret_upper_exp, secret_lower_exp};
#[doc(hidden)]
pub use core::fmt::{secret_pointer};

7
src/libstd/io/net/unix.rs
View File

@ -26,12 +26,7 @@ instances as clients.
use prelude::*;
use c_str::ToCStr;
use clone::Clone;
use io::{Listener, Acceptor, Reader, Writer, IoResult, IoError};
use io::{standard_error, TimedOut};
use kinds::Send;
use boxed::Box;
use io::{Listener, Acceptor, IoResult, IoError, TimedOut, standard_error};
use rt::rtio::{IoFactory, LocalIo, RtioUnixListener};
use rt::rtio::{RtioUnixAcceptor, RtioPipe};
use time::Duration;

1
src/libstd/io/pipe.rs
View File

@ -20,7 +20,6 @@ use prelude::*;
use io::{IoResult, IoError};
use libc;
use os;
use boxed::Box;
use rt::rtio::{RtioPipe, LocalIo};
/// A synchronous, in-memory pipe.

1
src/libstd/io/process.rs
View File

@ -20,7 +20,6 @@ use io::{IoResult, IoError};
use io;
use libc;
use mem;
use boxed::Box;
use rt::rtio::{RtioProcess, ProcessConfig, IoFactory, LocalIo};
use rt::rtio;
use c_str::CString;

1
src/libstd/io/util.rs
View File

@ -13,7 +13,6 @@
use prelude::*;
use cmp;
use io;
use boxed::Box;
use slice::bytes::MutableByteVector;
/// Wraps a `Reader`, limiting the number of bytes that can be read from it.

4
src/libstd/lib.rs
View File

@ -107,10 +107,14 @@
#![feature(macro_rules, globs, managed_boxes, linkage)]
#![feature(default_type_params, phase, lang_items, unsafe_destructor)]
#![feature(import_shadowing)]
// Don't link to std. We are std.
#![no_std]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#![allow(deprecated)]
#![deny(missing_doc)]

1
src/libstd/num/f32.rs
View File

@ -22,7 +22,6 @@ use intrinsics;
use libc::c_int;
use num::strconv;
use num;
use string::String;
pub use core::f32::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE};
pub use core::f32::{MIN_POS_VALUE, MAX_VALUE, MIN_EXP, MAX_EXP, MIN_10_EXP};

1
src/libstd/num/f64.rs
View File

@ -21,7 +21,6 @@ use intrinsics;
use libc::c_int;
use num::strconv;
use num;
use string::String;
pub use core::f64::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE};
pub use core::f64::{MIN_POS_VALUE, MAX_VALUE, MIN_EXP, MAX_EXP, MIN_10_EXP};

3
src/libsync/atomic.rs
View File

@ -103,10 +103,9 @@
#![allow(deprecated)]
use core::prelude::*;
use alloc::boxed::Box;
use core::mem;
use core::prelude::{Drop, None, Option, Some};
pub use core::atomic::{AtomicBool, AtomicInt, AtomicUint, AtomicPtr};
pub use core::atomic::{Ordering, Relaxed, Release, Acquire, AcqRel, SeqCst};

1
src/libsync/comm/sync.rs
View File

@ -37,7 +37,6 @@ use core::prelude::*;
use alloc::boxed::Box;
use collections::Vec;
use collections::Collection;
use core::mem;
use core::cell::UnsafeCell;
use rustrt::local::Local;

4
src/libsync/lib.rs
View File

@ -28,9 +28,13 @@
html_playground_url = "http://play.rust-lang.org/")]
#![feature(phase, globs, macro_rules, unsafe_destructor)]
#![feature(import_shadowing)]
#![deny(missing_doc)]
#![no_std]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[phase(plugin, link)] extern crate core;
extern crate alloc;
extern crate collections;

2
src/libsyntax/ext/deriving/generic/mod.rs
View File

@ -198,7 +198,7 @@ use owned_slice::OwnedSlice;
use parse::token::InternedString;
use parse::token::special_idents;
use self::ty::*;
use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self, Ty};
pub mod ty;

5
src/libsyntax/lib.rs
View File

@ -24,9 +24,12 @@
html_root_url = "http://doc.rust-lang.org/master/")]
#![feature(macro_rules, globs, managed_boxes, default_type_params, phase)]
#![feature(quote, struct_variant, unsafe_destructor)]
#![feature(quote, struct_variant, unsafe_destructor, import_shadowing)]
#![allow(deprecated)]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
extern crate fmt_macros;
extern crate debug;
#[phase(plugin, link)] extern crate log;

91
src/libsyntax/parse/token.rs
View File

@ -456,62 +456,63 @@ declare_special_idents_and_keywords! {
(7, opaque, "<opaque>");
(8, unnamed_field, "<unnamed_field>");
(9, type_self, "Self");
(10, prelude_import, "prelude_import");
}
pub mod keywords {
// These ones are variants of the Keyword enum
'strict:
(10, As, "as");
(11, Break, "break");
(12, Crate, "crate");
(13, Else, "else");
(14, Enum, "enum");
(15, Extern, "extern");
(16, False, "false");
(17, Fn, "fn");
(18, For, "for");
(19, If, "if");
(20, Impl, "impl");
(21, In, "in");
(22, Let, "let");
(23, Loop, "loop");
(24, Match, "match");
(25, Mod, "mod");
(26, Mut, "mut");
(27, Once, "once");
(28, Pub, "pub");
(29, Ref, "ref");
(30, Return, "return");
(11, As, "as");
(12, Break, "break");
(13, Crate, "crate");
(14, Else, "else");
(15, Enum, "enum");
(16, Extern, "extern");
(17, False, "false");
(18, Fn, "fn");
(19, For, "for");
(20, If, "if");
(21, Impl, "impl");
(22, In, "in");
(23, Let, "let");
(24, Loop, "loop");
(25, Match, "match");
(26, Mod, "mod");
(27, Mut, "mut");
(28, Once, "once");
(29, Pub, "pub");
(30, Ref, "ref");
(31, Return, "return");
// Static and Self are also special idents (prefill de-dupes)
(super::STATIC_KEYWORD_NAME_NUM, Static, "static");
(super::SELF_KEYWORD_NAME_NUM, Self, "self");
(31, Struct, "struct");
(32, Super, "super");
(33, True, "true");
(34, Trait, "trait");
(35, Type, "type");
(36, Unsafe, "unsafe");
(37, Use, "use");
(38, Virtual, "virtual");
(39, While, "while");
(40, Continue, "continue");
(41, Proc, "proc");
(42, Box, "box");
(43, Const, "const");
(44, Where, "where");
(32, Struct, "struct");
(33, Super, "super");
(34, True, "true");
(35, Trait, "trait");
(36, Type, "type");
(37, Unsafe, "unsafe");
(38, Use, "use");
(39, Virtual, "virtual");
(40, While, "while");
(41, Continue, "continue");
(42, Proc, "proc");
(43, Box, "box");
(44, Const, "const");
(45, Where, "where");
'reserved:
(45, Alignof, "alignof");
(46, Be, "be");
(47, Offsetof, "offsetof");
(48, Priv, "priv");
(49, Pure, "pure");
(50, Sizeof, "sizeof");
(51, Typeof, "typeof");
(52, Unsized, "unsized");
(53, Yield, "yield");
(54, Do, "do");
(46, Alignof, "alignof");
(47, Be, "be");
(48, Offsetof, "offsetof");
(49, Priv, "priv");
(50, Pure, "pure");
(51, Sizeof, "sizeof");
(52, Typeof, "typeof");
(53, Unsized, "unsized");
(54, Yield, "yield");
(55, Do, "do");
}
}

2
src/libuuid/lib.rs
View File

@ -523,7 +523,7 @@ impl rand::Rand for Uuid {
}
#[cfg(test)]
mod test {
mod uuidtest {
use super::{Uuid, VariantMicrosoft, VariantNCS, VariantRFC4122,
Version1Mac, Version2Dce, Version3Md5, Version4Random,
Version5Sha1};

4
src/test/compile-fail/ambig_impl_2_exe.rs
View File

@ -11,9 +11,9 @@
// aux-build:ambig_impl_2_lib.rs
extern crate ambig_impl_2_lib;
use ambig_impl_2_lib::me;
trait me {
trait me2 {
fn me(&self) -> uint;
}
impl me for uint { fn me(&self) -> uint { *self } } //~ NOTE is `uint.me::me`
impl me2 for uint { fn me(&self) -> uint { *self } } //~ NOTE is `uint.me2::me`
fn main() { 1u.me(); } //~ ERROR multiple applicable methods in scope
//~^ NOTE is `ambig_impl_2_lib::uint.me::me`

56
src/test/compile-fail/issue-7663.rs
View File

@ -1,56 +0,0 @@
// 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.
#![feature(globs)]
#![deny(unused_imports)]
#![allow(dead_code)]
mod test1 {
mod foo { pub fn p() -> int { 1 } }
mod bar { pub fn p() -> int { 2 } }
pub mod baz {
use test1::foo::*; //~ ERROR: unused import
use test1::bar::*;
pub fn my_main() { assert!(p() == 2); }
}
}
mod test2 {
mod foo { pub fn p() -> int { 1 } }
mod bar { pub fn p() -> int { 2 } }
pub mod baz {
use test2::foo::p; //~ ERROR: unused import
use test2::bar::p;
pub fn my_main() { assert!(p() == 2); }
}
}
mod test3 {
mod foo { pub fn p() -> int { 1 } }
mod bar { pub fn p() -> int { 2 } }
pub mod baz {
use test3::foo::*; //~ ERROR: unused import
use test3::bar::p;
pub fn my_main() { assert!(p() == 2); }
}
}
fn main() {
}

7
src/test/compile-fail/issue-9957.rs
View File

@ -8,13 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
pub extern crate std; //~ ERROR: `pub` visibility is not allowed
extern crate std;
pub use std::bool;
use std::bool;
pub extern crate core; //~ ERROR: `pub` visibility is not allowed
fn main() {
pub use std::bool; //~ ERROR: imports in functions are never reachable
use std::bool;
}

86
src/test/compile-fail/lint-unused-import-tricky-globs.rs
View File

@ -1,86 +0,0 @@
// Copyright 2013 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.
#![feature(globs)]
#![deny(unused_imports)]
#![allow(dead_code)]
mod A {
pub fn p() {}
}
mod B {
pub fn p() {}
}
mod C {
pub fn q() {}
}
mod D {
pub fn q() {}
}
mod E {
pub fn r() {}
}
mod F {
pub fn r() {}
}
mod G {
pub fn s() {}
pub fn t() {}
}
mod H {
pub fn s() {}
}
mod I {
pub fn u() {}
pub fn v() {}
}
mod J {
pub fn u() {}
pub fn v() {}
}
mod K {
pub fn w() {}
}
mod L {
pub fn w() {}
}
mod m {
use A::p; //~ ERROR: unused import
use B::p;
use C::q; //~ ERROR: unused import
use D::*;
use E::*; //~ ERROR: unused import
use F::r;
use G::*;
use H::*;
use I::*;
use J::v;
use K::*; //~ ERROR: unused import
use L::*;
#[main]
fn my_main() {
p();
q();
r();
s();
t();
u();
v();
w();
}
}

48
src/test/compile-fail/lint-unused-import-tricky-names.rs
View File

@ -1,48 +0,0 @@
// Copyright 2013 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.
#![deny(unused_imports)]
#![allow(non_camel_case_types)]
#![allow(dead_code)]
// Regression test for issue #6633
mod issue6633 {
use self::foo::name::name; //~ ERROR: unused import
use self::foo::name;
pub mod foo {
pub mod name {
pub type a = int;
pub mod name {
pub type a = f64;
}
}
}
fn bar() -> name::a { 1 }
}
// Regression test for issue #6935
mod issue6935 {
use self::a::foo::a::foo;
use self::a::foo; //~ ERROR: unused import
pub mod a {
pub mod foo {
pub mod a {
pub fn foo() {}
}
}
}
fn bar() { foo(); }
}
fn main(){}

1
src/test/compile-fail/privacy-ns2.rs
View File

@ -70,7 +70,6 @@ pub mod foo3 {
fn test_unused3() {
use foo3::Bar; //~ ERROR `Bar` is private
use foo3::{Bar,Baz}; //~ ERROR `Bar` is private
}
fn test_single3() {

1
src/test/compile-fail/privacy1.rs
View File

@ -171,7 +171,6 @@ pub mod mytest {
// Even though the inner `A` struct is a publicly exported item (usable from
// external crates through `foo::foo`, it should not be accessible through
// its definition path (which has the private `i` module).
use self::foo::foo;
use self::foo::i::A; //~ ERROR: type `A` is inaccessible
//~^ NOTE: module `i` is private

15
src/test/compile-fail/resolve-conflict-extern-crate-vs-extern-crate.rs Normal file
View File

@ -0,0 +1,15 @@
// 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 std;
//~^ ERROR an external crate named `std` has already been imported
fn main(){}

15
src/test/compile-fail/resolve-conflict-import-vs-extern-crate.rs Normal file
View File

@ -0,0 +1,15 @@
// 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.
use std = std::slice; //~ ERROR import conflicts with imported crate
fn main() {
}

17
src/test/compile-fail/resolve-conflict-import-vs-import.rs Normal file
View File

@ -0,0 +1,17 @@
// 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.
use std::mem::transmute;
use std::mem::transmute;
//~^ ERROR a value named `transmute` has already been imported
fn main() {
}

15
src/test/compile-fail/resolve-conflict-item-vs-extern-crate.rs Normal file
View File

@ -0,0 +1,15 @@
// 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.
fn std() {} //~ ERROR the name `std` conflicts with an external crate
fn main() {
}

18
src/test/compile-fail/resolve-conflict-item-vs-import.rs Normal file
View File

@ -0,0 +1,18 @@
// 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.
use std::mem::transmute;
//~^ ERROR import conflicts with value in this module
fn transmute() {}
fn main() {
}

33
src/test/compile-fail/resolve-priv-shadowing-pub.rs
View File

@ -1,33 +0,0 @@
// 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.
mod a {
pub fn foobar() -> int { 1 }
}
mod b {
pub fn foobar() -> int { 2 }
}
mod c {
// Technically the second use shadows the first, but in theory it should
// only be shadowed for this module. The implementation of resolve currently
// doesn't implement this, so this test is ensuring that using "c::foobar"
// is *not* getting b::foobar. Today it's an error, but perhaps one day it
// can correctly get a::foobar instead.
pub use a::foobar;
use b::foobar;
}
fn main() {
assert_eq!(c::foobar(), 1);
//~^ ERROR: unresolved name `c::foobar`
}

2
src/test/compile-fail/unused-attr.rs
View File

@ -13,7 +13,7 @@
#![foo] //~ ERROR unused attribute
#[foo] //~ ERROR unused attribute
extern crate std;
extern crate core;
#[foo] //~ ERROR unused attribute
use std::collections;

3
src/test/compile-fail/use-mod-3.rs
View File

@ -12,9 +12,8 @@ use foo::bar::{
mod //~ ERROR module `bar` is private
};
use foo::bar::{
Bar, //~ ERROR type `Bar` is inaccessible
Bar //~ ERROR type `Bar` is inaccessible
//~^ NOTE module `bar` is private
mod //~ ERROR module `bar` is private
};
mod foo {

1
src/test/pretty/issue-4264.pp
View File

@ -4,6 +4,7 @@
#[phase(plugin, link)]
extern crate std = "std";
extern crate rt = "native";
#[prelude_import]
use std::prelude::*;
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at

4
src/test/run-fail/glob-use-std.rs
View File

@ -10,6 +10,10 @@
// Issue #7580
// ignore-pretty
//
// Expanded pretty printing causes resolve conflicts.
// error-pattern:fail works
#![feature(globs)]

2
src/test/run-pass/core-run-destroy.rs
View File

@ -41,7 +41,7 @@ macro_rules! iotest (
use std::str;
use std::io::process::Command;
use native;
use super::*;
use super::{sleeper, test_destroy_actually_kills};
fn f() $b

4
src/test/run-pass/extern-mod-ordering-exe.rs
View File

@ -12,8 +12,8 @@
extern crate extern_mod_ordering_lib;
use extern_mod_ordering_lib::extern_mod_ordering_lib;
use the_lib = extern_mod_ordering_lib::extern_mod_ordering_lib;
pub fn main() {
extern_mod_ordering_lib::f();
the_lib::f();
}

1
src/test/run-pass/issue-11736.rs
View File

@ -9,7 +9,6 @@
// except according to those terms.
extern crate collections;
extern crate std;
use std::collections::Bitv;

2
src/test/run-pass/issue-12612.rs
View File

@ -14,8 +14,6 @@
extern crate foo = "issue-12612-1";
extern crate bar = "issue-12612-2";
use foo::bar;
mod test {
use bar::baz;
}

1
src/test/run-pass/issue-14082.rs
View File

@ -14,7 +14,6 @@
use foo::GC;
mod foo {
use d::*;
pub use m::GC; // this should shadow d::GC
}

2
src/test/run-pass/issue-14330.rs
View File

@ -10,6 +10,6 @@
#![feature(phase)]
#[phase(plugin, link)] extern crate std;
#[phase(plugin, link)] extern crate std2 = "std";
fn main() {}

2
src/test/run-pass/issue-5521.rs
View File

@ -13,7 +13,7 @@
extern crate foo = "issue-5521";
fn foo(a: foo::map) {
fn bar(a: foo::map) {
if false {
fail!();
} else {

2
src/test/run-pass/issue-7663.rs
View File

@ -30,7 +30,6 @@ mod test2 {
mod bar { pub fn p() -> int { 2 } }
pub mod baz {
use test2::foo::p;
use test2::bar::p;
pub fn my_main() { assert!(p() == 2); }
@ -43,7 +42,6 @@ mod test3 {
mod bar { pub fn p() -> int { 2 } }
pub mod baz {
use test3::foo::*;
use test3::bar::p;
pub fn my_main() { assert!(p() == 2); }

4
src/test/run-pass/match-ref-binding-in-guard-3256.rs
View File

@ -8,11 +8,9 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::rt;
pub fn main() {
unsafe {
let x = Some(rt::exclusive::Exclusive::new(true));
let x = Some(::std::rt::exclusive::Exclusive::new(true));
match x {
Some(ref z) if *z.lock() => {
assert!(*z.lock());

6
src/test/run-pass/privacy-ns.rs
View File

@ -27,8 +27,6 @@ pub mod foo1 {
}
fn test_unused1() {
use foo1::Bar;
use foo1::{Bar,Baz};
use foo1::*;
}
@ -60,8 +58,6 @@ pub mod foo2 {
}
fn test_unused2() {
use foo2::Bar;
use foo2::{Bar,Baz};
use foo2::*;
}
@ -93,8 +89,6 @@ pub mod foo3 {
}
fn test_unused3() {
use foo3::Bar;
use foo3::{Bar,Baz};
use foo3::*;
}

1
src/test/run-pass/type-sizes.rs
View File

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
extern crate std;
use std::mem::size_of;
struct t {a: u8, b: i8}

4
src/test/run-pass/writealias.rs
View File

@ -9,15 +9,13 @@
// except according to those terms.
use std::rt;
struct Point {x: int, y: int, z: int}
fn f(p: &mut Point) { p.z = 13; }
pub fn main() {
unsafe {
let x = Some(rt::exclusive::Exclusive::new(true));
let x = Some(::std::rt::exclusive::Exclusive::new(true));
match x {
Some(ref z) if *z.lock() => {
assert!(*z.lock());