Rationale for this, is that I lurked `ulimit -c unlimited` into my .profile to debug an unrelated crash, that I kept forgetting to set before hand. I then ran the test suite and discovered that I had 150 gigs of core dumps in `/cores`.
Very open to another approach, or to setting the limit to something higher than 0, but I think it would be nice if the build system tried to save you from yourself here.
Peter Williams <peter@newton.cx>
Peter Zotov <whitequark@whitequark.org>
Petter Remen <petter.remen@gmail.com>
-Phil Dawes <pdawes@drw.com>
+Phil Dawes <phil@phildawes.net>
Phil Ruffwind <rf@rufflewind.com>
Philip Munksgaard <pmunksgaard@gmail.com>
Philipp Brüschweiler <blei42@gmail.com>
CFG_OSTYPE=pc-windows-gnu
;;
-# Thad's Cygwin identifers below
+# Thad's Cygwin identifiers below
# Vista 32 bit
CYGWIN_NT-6.0)
opt valgrind 0 "run tests with valgrind (memcheck by default)"
opt helgrind 0 "run tests with helgrind instead of memcheck"
opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind"
-opt docs 1 "build documentation"
+opt docs 1 "build standard library documentation"
+opt compiler-docs 0 "build compiler documentation"
opt optimize 1 "build optimized rust code"
opt optimize-cxx 1 "build optimized C++ code"
opt optimize-llvm 1 "build optimized LLVM"
# You should not need to edit below this line
################################################################################
+# On channels where the only usable crate is std, only build documentation for
+# std. This keeps distributions small and doesn't clutter up the API docs with
+# confusing internal details from the crates behind the facade.
+#
+# (Disabled while cmr figures out how to change rustdoc to make reexports work
+# slightly nicer. Otherwise, all cross-crate links to Vec will go to
+# libcollections, breaking them, and [src] links for anything reexported will
+# not work.)
+
+#ifeq ($(CFG_RELEASE_CHANNEL),stable)
+#DOC_CRATES := std
+#else
+#ifeq ($(CFG_RELEASE_CHANNEL),beta)
+#DOC_CRATES := std
+#else
DOC_CRATES := $(filter-out rustc, \
- $(filter-out rustc_trans, \
- $(filter-out rustc_typeck, \
- $(filter-out rustc_borrowck, \
- $(filter-out rustc_resolve, \
- $(filter-out rustc_driver, \
- $(filter-out rustc_privacy, \
- $(filter-out rustc_lint, \
- $(filter-out log, \
- $(filter-out getopts, \
- $(filter-out syntax, $(CRATES))))))))))))
+ $(filter-out rustc_trans, \
+ $(filter-out rustc_typeck, \
+ $(filter-out rustc_borrowck, \
+ $(filter-out rustc_resolve, \
+ $(filter-out rustc_driver, \
+ $(filter-out rustc_privacy, \
+ $(filter-out rustc_lint, \
+ $(filter-out log, \
+ $(filter-out getopts, \
+ $(filter-out syntax, $(CRATES))))))))))))
+#endif
+#endif
COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \
rustc_typeck rustc_driver syntax rustc_privacy \
rustc_lint
endef
$(foreach crate,$(DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),DOC_TARGETS)))
-$(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
+
+ifdef CFG_COMPILER_DOCS
+ $(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
+endif
ifdef CFG_DISABLE_DOCS
$(info cfg: disabling doc build (CFG_DISABLE_DOCS))
ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
- # On Bitrig, we need the relocation model to be PIC for everthing
+ # On Bitrig, we need the relocation model to be PIC for everything
ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
LLVM_MC_RELOCATION_MODEL="pic"
else
# on $$(TSREQ$(1)_T_$(2)_H_$(3)), to ensure that no products will be
# put into the target area until after the get-snapshot.py script has
# had its chance to clean it out; otherwise the other products will be
-# inadvertantly included in the clean out.
+# inadvertently included in the clean out.
SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD))/rustc$(X_$(CFG_BUILD))
define TARGET_HOST_RULES
#![feature(box_syntax)]
#![feature(collections)]
-#![feature(int_uint)]
#![feature(old_io)]
-#![feature(old_path)]
#![feature(rustc_private)]
#![feature(unboxed_closures)]
#![feature(std_misc)]
use std::path::Path;
pub struct ExpectedError {
- pub line: uint,
+ pub line: usize,
pub kind: String,
pub msg: String,
}
#[derive(PartialEq, Debug)]
-enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
+enum WhichLine { ThisLine, FollowPrevious(usize), AdjustBackward(usize) }
/// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"
/// The former is a "follow" that inherits its target from the preceding line;
}).collect()
}
-fn parse_expected(last_nonfollow_error: Option<uint>,
- line_num: uint,
+fn parse_expected(last_nonfollow_error: Option<usize>,
+ line_num: usize,
line: &str) -> Option<(WhichLine, ExpectedError)> {
let start = match line.find("//~") { Some(i) => i, None => return None };
let (follow, adjusts) = if line.char_at(start + 3) == '|' {
}
}
-pub fn gdb_version_to_int(version_string: &str) -> int {
+pub fn gdb_version_to_int(version_string: &str) -> isize {
let error_string = format!(
"Encountered GDB version string with unexpected format: {}",
version_string);
panic!("{}", error_string);
}
- let major: int = components[0].parse().ok().expect(&error_string);
- let minor: int = components[1].parse().ok().expect(&error_string);
+ let major: isize = components[0].parse().ok().expect(&error_string);
+ let minor: isize = components[1].parse().ok().expect(&error_string);
return major * 1000 + minor;
}
-pub fn lldb_version_to_int(version_string: &str) -> int {
+pub fn lldb_version_to_int(version_string: &str) -> isize {
let error_string = format!(
"Encountered LLDB version string with unexpected format: {}",
version_string);
let error_string = error_string;
- let major: int = version_string.parse().ok().expect(&error_string);
+ let major: isize = version_string.parse().ok().expect(&error_string);
return major;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![allow(deprecated)] // for old path, for dynamic_lib
-
use std::dynamic_lib::DynamicLibrary;
use std::io::prelude::*;
-use std::old_path::Path;
+use std::path::PathBuf;
use std::process::{ExitStatus, Command, Child, Output, Stdio};
fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
// search path for the child.
let mut path = DynamicLibrary::search_path();
match aux_path {
- Some(p) => path.insert(0, Path::new(p)),
+ Some(p) => path.insert(0, PathBuf::from(p)),
None => {}
}
- path.insert(0, Path::new(lib_path));
+ path.insert(0, PathBuf::from(lib_path));
// Add the new dylib search path var
let var = DynamicLibrary::envvar();
let newpath = DynamicLibrary::create_path(&path);
- let newpath = String::from_utf8(newpath).unwrap();
+ let newpath = newpath.to_str().unwrap().to_string();
cmd.env(var, &newpath);
}
struct DebuggerCommands {
commands: Vec<String>,
check_lines: Vec<String>,
- breakpoint_lines: Vec<uint>,
+ breakpoint_lines: Vec<usize>,
}
fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
scan_string(line, "warning", &mut i));
}
-fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
+fn scan_until_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
if *idx >= haystack.len() {
return false;
}
return true;
}
-fn scan_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
+fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
if *idx >= haystack.len() {
return false;
}
return true;
}
-fn scan_integer(haystack: &str, idx: &mut uint) -> bool {
+fn scan_integer(haystack: &str, idx: &mut usize) -> bool {
let mut i = *idx;
while i < haystack.len() {
let ch = haystack.char_at(i);
return true;
}
-fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
+fn scan_string(haystack: &str, needle: &str, idx: &mut usize) -> bool {
let mut haystack_i = *idx;
let mut needle_i = 0;
while needle_i < needle.len() {
}
-fn count_extracted_lines(p: &Path) -> uint {
+fn count_extracted_lines(p: &Path) -> usize {
let mut x = Vec::new();
File::open(&p.with_extension("ll")).unwrap().read_to_end(&mut x).unwrap();
let x = str::from_utf8(&x).unwrap();
/// Conversion table from triple OS name to Rust SYSNAME
const OS_TABLE: &'static [(&'static str, &'static str)] = &[
- ("mingw32", "windows"),
- ("win32", "windows"),
- ("windows", "windows"),
- ("darwin", "macos"),
("android", "android"),
- ("linux", "linux"),
- ("freebsd", "freebsd"),
- ("dragonfly", "dragonfly"),
("bitrig", "bitrig"),
+ ("darwin", "macos"),
+ ("dragonfly", "dragonfly"),
+ ("freebsd", "freebsd"),
+ ("ios", "ios"),
+ ("linux", "linux"),
+ ("mingw32", "windows"),
("openbsd", "openbsd"),
+ ("win32", "windows"),
+ ("windows", "windows"),
];
const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
- ("i386", "x86"),
- ("i686", "x86"),
+ ("aarch64", "aarch64"),
("amd64", "x86_64"),
- ("x86_64", "x86_64"),
- ("sparc", "sparc"),
- ("powerpc", "powerpc"),
- ("arm64", "aarch64"),
("arm", "arm"),
- ("aarch64", "aarch64"),
+ ("arm64", "aarch64"),
+ ("hexagon", "hexagon"),
+ ("i386", "x86"),
+ ("i686", "x86"),
("mips", "mips"),
- ("xcore", "xcore"),
("msp430", "msp430"),
- ("hexagon", "hexagon"),
+ ("powerpc", "powerpc"),
("s390x", "systemz"),
+ ("sparc", "sparc"),
+ ("x86_64", "x86_64"),
+ ("xcore", "xcore"),
];
pub fn get_os(triple: &str) -> &'static str {
A number of minor features of Rust are not central enough to have their own
syntax, and yet are not implementable as functions. Instead, they are given
-names, and invoked through a consistent syntax: `name!(...)`. Examples include:
-
-* `format!` : format data into a string
-* `env!` : look up an environment variable's value at compile time
-* `file!`: return the path to the file being compiled
-* `stringify!` : pretty-print the Rust expression given as an argument
-* `include!` : include the Rust expression in the given file
-* `include_str!` : include the contents of the given file as a string
-* `include_bytes!` : include the contents of the given file as a binary blob
-* `error!`, `warn!`, `info!`, `debug!` : provide diagnostic information.
-
-All of the above extensions are expressions with values.
+names, and invoked through a consistent syntax: `some_extension!(...)`.
Users of `rustc` can define new syntax extensions in two ways:
pairs when they occur at the beginning of, or immediately after, a `$(...)*`;
requiring a distinctive token in front can solve the problem.
-## Syntax extensions useful in macros
-
-* `stringify!` : turn the identifier argument into a string literal
-* `concat!` : concatenates a comma-separated list of literals
-
-## Syntax extensions for macro debugging
-
-* `log_syntax!` : print out the arguments at compile time
-* `trace_macros!` : supply `true` or `false` to enable or disable macro expansion logging
-
-## Quasiquoting
-
-The following syntax extensions are used for quasiquoting Rust syntax trees,
-usually in [procedural macros](book/plugins.html#syntax-extensions):
-
-* `quote_expr!`
-* `quote_item!`
-* `quote_pat!`
-* `quote_stmt!`
-* `quote_tokens!`
-* `quote_matcher!`
-* `quote_ty!`
-* `quote_attr!`
-
-Keep in mind that when `$name : ident` appears in the input to
-`quote_tokens!`, the result contains unquoted `name` followed by two tokens.
-However, input of the same form passed to `quote_matcher!` becomes a
-quasiquoted MBE-matcher of a nonterminal. No unquotation happens. Otherwise
-the result of `quote_matcher!` is identical to that of `quote_tokens!`.
-
-Documentation is very limited at the moment.
-
# Crates and source files
Rust is a *compiled* language. Its semantics obey a *phase distinction*
extern crate std; // equivalent to: extern crate std as std;
-extern crate "std" as ruststd; // linking to 'std' under another name
+extern crate std as ruststd; // linking to 'std' under another name
```
##### Use declarations
* Data races
* Dereferencing a null/dangling raw pointer
-* Mutating an immutable value/reference without `UnsafeCell`
* Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values)
(uninitialized) memory
* Breaking the [pointer aliasing
rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules)
with raw pointers (a subset of the rules used by C)
+* `&mut` and `&` follow LLVM’s scoped [noalias] model, except if the `&T`
+ contains an `UnsafeCell<U>`. Unsafe code must not violate these aliasing
+ guarantees.
+* Mutating an immutable value/reference without `UnsafeCell<U>`
* Invoking undefined behavior via compiler intrinsics:
* Indexing outside of the bounds of an object with `std::ptr::offset`
(`offset` intrinsic), with
code. Rust's failure system is not compatible with exception handling in
other languages. Unwinding must be caught and handled at FFI boundaries.
+[noalias]: http://llvm.org/docs/LangRef.html#noalias
+
##### Behaviour not considered unsafe
This is a list of behaviour not considered *unsafe* in Rust terms, but that may
Constants should in general be preferred over statics, unless large amounts of
data are being stored, or single-address and mutability properties are required.
-```
-use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
-
-// Note that ATOMIC_USIZE_INIT is a *const*, but it may be used to initialize a
-// static. This static can be modified, so it is not placed in read-only memory.
-static COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
-
-// This table is a candidate to be placed in read-only memory.
-static TABLE: &'static [usize] = &[1, 2, 3, /* ... */];
-
-for slot in TABLE.iter() {
- println!("{}", slot);
-}
-COUNTER.fetch_add(1, Ordering::SeqCst);
-```
-
#### Mutable statics
If a static item is declared with the `mut` keyword, then it is allowed to
}
```
-Supported traits for `derive` are:
-
-* Comparison traits: `PartialEq`, `Eq`, `PartialOrd`, `Ord`.
-* Serialization: `Encodable`, `Decodable`. These require `serialize`.
-* `Clone`, to create `T` from `&T` via a copy.
-* `Default`, to create an empty instance of a data type.
-* `FromPrimitive`, to create an instance from a numeric primitive.
-* `Hash`, to iterate over the bytes in a data type.
-* `Rand`, to create a random instance of a data type.
-* `Debug`, to format a value using the `{:?}` formatter.
-* `Copy`, for "Plain Old Data" types which can be copied by simply moving bits.
-
### Compiler Features
Certain aspects of Rust may be implemented in the compiler, but they're not
The currently implemented features of the reference compiler are:
-* `advanced_slice_patterns` - see the [match expressions](#match-expressions)
+* `advanced_slice_patterns` - See the [match expressions](#match-expressions)
section for discussion; the exact semantics of
- slice patterns are subject to change.
+ slice patterns are subject to change, so some types
+ are still unstable.
+
+* `slice_patterns` - OK, actually, slice patterns are just scary and
+ completely unstable.
* `asm` - The `asm!` macro provides a means for inline assembly. This is often
useful, but the exact syntax for this feature along with its
* `intrinsics` - Allows use of the "rust-intrinsics" ABI. Compiler intrinsics
are inherently unstable and no promise about them is made.
-* `int_uint` - Allows the use of the `int` and `uint` types, which are deprecated.
- Use `isize` and `usize` instead.
-
* `lang_items` - Allows use of the `#[lang]` attribute. Like `intrinsics`,
lang items are inherently unstable and no promise about them
is made.
```
# struct Point { x: f64, y: f64 }
# struct TuplePoint(f64, f64);
-# mod game { pub struct User<'a> { pub name: &'a str, pub age: u32, pub score: uint } }
+# mod game { pub struct User<'a> { pub name: &'a str, pub age: u32, pub score: usize } }
# struct Cookie; fn some_fn<T>(t: T) {}
Point {x: 10.0, y: 20.0};
TuplePoint(10.0, 20.0);
corresponding slice to the variable. Example:
```
-# #![feature(advanced_slice_patterns)]
+# #![feature(advanced_slice_patterns, slice_patterns)]
fn is_symmetric(list: &[u32]) -> bool {
match list {
[] | [_] => true,
#![feature(box_patterns)]
#![feature(box_syntax)]
-enum List { Nil, Cons(uint, Box<List>) }
+enum List { Nil, Cons(u32, Box<List>) }
fn is_sorted(list: &List) -> bool {
match *list {
`self` refers to the value of type `String` that is the receiver for a call to
the method `make_string`.
-## Type kinds
-
-Types in Rust are categorized into kinds, based on various properties of the
-components of the type. The kinds are:
-
-* `Send`
- : Types of this kind can be safely sent between threads.
- This kind includes scalars, boxes, procs, and
- structural types containing only other owned types.
- All `Send` types are `'static`.
-* `Copy`
- : Types of this kind consist of "Plain Old Data"
- which can be copied by simply moving bits.
- All values of this kind can be implicitly copied.
- This kind includes scalars and immutable references,
- as well as structural types containing other `Copy` types.
-* `'static`
- : Types of this kind do not contain any references (except for
- references with the `static` lifetime, which are allowed).
- This can be a useful guarantee for code
- that breaks borrowing assumptions
- using [`unsafe` operations](#unsafe-functions).
-* `Drop`
- : This is not strictly a kind,
- but its presence interacts with kinds:
- the `Drop` trait provides a single method `drop`
- that takes no parameters,
- and is run when values of the type are dropped.
- Such a method is called a "destructor",
- and are always executed in "top-down" order:
- a value is completely destroyed
- before any of the values it owns run their destructors.
- Only `Send` types can implement `Drop`.
-
-* _Default_
- : Types with destructors, closure environments,
- and various other _non-first-class_ types,
- are not copyable at all.
- Such types can usually only be accessed through pointers,
- or in some cases, moved between mutable locations.
-
-Kinds can be supplied as _bounds_ on type parameters, like traits, in which
-case the parameter is constrained to types satisfying that kind.
-
-By default, type parameters do not carry any assumed kind-bounds at all. When
-instantiating a type parameter, the kind bounds on the parameter are checked to
-be the same or narrower than the kind of the type that it is instantiated with.
-
-Sending operations are not part of the Rust language, but are implemented in
-the library. Generic functions that send values bound the kind of these values
-to sendable.
-
-# Memory and concurrency models
-
-Rust has a memory model centered around concurrently-executing _threads_. Thus
-its memory model and its concurrency model are best discussed simultaneously,
-as parts of each only make sense when considered from the perspective of the
-other.
-
-When reading about the memory model, keep in mind that it is partitioned in
-order to support threads; and when reading about threads, keep in mind that their
-isolation and communication mechanisms are only possible due to the ownership
-and lifetime semantics of the memory model.
-
-## Memory model
-
-A Rust program's memory consists of a static set of *items*, a set of
-[threads](#threads) each with its own *stack*, and a *heap*. Immutable portions of
-the heap may be shared between threads, mutable portions may not.
+# The `Copy` trait
+
+Rust has a special trait, `Copy`, which when implemented changes the semantics
+of a value. Values whose type implements `Copy` are copied rather than moved
+upon assignment.
+
+# The `Sized` trait
+
+`Sized` is a special trait which indicates that the size of this type is known
+at compile-time.
+
+# The `Drop` trait
+
+The `Drop` trait provides a destructor, to be run whenever a value of this type
+is to be destroyed.
+
+# Memory model
+
+A Rust program's memory consists of a static set of *items* and a *heap*.
+Immutable portions of the heap may be shared between threads, mutable portions
+may not.
Allocations in the stack consist of *slots*, and allocations in the heap
consist of *boxes*.
value calculated at compile-time and stored uniquely in the memory image of the
rust process. Items are neither dynamically allocated nor freed.
-A thread's _stack_ consists of activation frames automatically allocated on entry
-to each function as the thread executes. A stack allocation is reclaimed when
-control leaves the frame containing it.
-
The _heap_ is a general term that describes boxes. The lifetime of an
allocation in the heap depends on the lifetime of the box values pointing to
it. Since box values may themselves be passed in and out of frames, or stored
### Memory ownership
-A thread owns all memory it can *safely* reach through local variables, as well
-as boxes and references.
-
-When a thread sends a value that has the `Send` trait to another thread, it loses
-ownership of the value sent and can no longer refer to it. This is statically
-guaranteed by the combined use of "move semantics", and the compiler-checked
-_meaning_ of the `Send` trait: it is only instantiated for (transitively)
-sendable kinds of data constructor and pointers, never including references.
-
When a stack frame is exited, its local allocations are all released, and its
references to boxes are dropped.
-When a thread finishes, its stack is necessarily empty and it therefore has no
-references to any boxes; the remainder of its heap is immediately freed.
-
### Memory slots
-A thread's stack contains slots.
-
A _slot_ is a component of a stack frame, either a function parameter, a
[temporary](#lvalues,-rvalues-and-temporaries), or a local variable.
local variables. Local variables can be used only after they have been
initialized; this is enforced by the compiler.
-### Boxes
-
-A _box_ is a reference to a heap allocation holding another value, which is
-constructed by the prefix operator `box`. When the standard library is in use,
-the type of a box is `std::owned::Box<T>`.
-
-An example of a box type and value:
-
-```
-let x: Box<i32> = Box::new(10);
-```
-
-Box values exist in 1:1 correspondence with their heap allocation, copying a
-box value makes a shallow copy of the pointer. Rust will consider a shallow
-copy of a box to move ownership of the value. After a value has been moved,
-the source location cannot be used unless it is reinitialized.
-
-```
-let x: Box<i32> = Box::new(10);
-let y = x;
-// attempting to use `x` will result in an error here
-```
-
-## Threads
-
-Rust's primary concurrency mechanism is called a **thread**.
-
-### Communication between threads
-
-Rust threads are isolated and generally unable to interfere with one another's
-memory directly, except through [`unsafe` code](#unsafe-functions). All
-contact between threads is mediated by safe forms of ownership transfer, and data
-races on memory are prohibited by the type system.
-
-When you wish to send data between threads, the values are restricted to the
-[`Send` type-kind](#type-kinds). Restricting communication interfaces to this
-kind ensures that no references move between threads. Thus access to an entire
-data structure can be mediated through its owning "root" value; no further
-locking or copying is required to avoid data races within the substructure of
-such a value.
-
-### Thread
-
-The _lifecycle_ of a threads consists of a finite set of states and events that
-cause transitions between the states. The lifecycle states of a thread are:
-
-* running
-* blocked
-* panicked
-* dead
-
-A thread begins its lifecycle — once it has been spawned — in the
-*running* state. In this state it executes the statements of its entry
-function, and any functions called by the entry function.
-
-A thread may transition from the *running* state to the *blocked* state any time
-it makes a blocking communication call. When the call can be completed —
-when a message arrives at a sender, or a buffer opens to receive a message
-— then the blocked thread will unblock and transition back to *running*.
-
-A thread may transition to the *panicked* state at any time, due being killed by
-some external event or internally, from the evaluation of a `panic!()` macro.
-Once *panicking*, a thread unwinds its stack and transitions to the *dead* state.
-Unwinding the stack of a thread is done by the thread itself, on its own control
-stack. If a value with a destructor is freed during unwinding, the code for the
-destructor is run, also on the thread's control stack. Running the destructor
-code causes a temporary transition to a *running* state, and allows the
-destructor code to cause any subsequent state transitions. The original thread
-of unwinding and panicking thereby may suspend temporarily, and may involve
-(recursive) unwinding of the stack of a failed destructor. Nonetheless, the
-outermost unwinding activity will continue until the stack is unwound and the
-thread transitions to the *dead* state. There is no way to "recover" from thread
-panics. Once a thread has temporarily suspended its unwinding in the *panicking*
-state, a panic occurring from within this destructor results in *hard* panic.
-A hard panic currently results in the process aborting.
-
-A thread in the *dead* state cannot transition to other states; it exists only to
-have its termination status inspected by other threads, and/or to await
-reclamation when the last reference to it drops.
-
# Runtime services, linkage and debugging
The Rust _runtime_ is a relatively compact collection of Rust code that
<h2 class="section-header"><a href="basic.html">Basics</a></h2>
This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax, and culminates
-in a small project: a guessing game.
+Rust. It has individual sections on each part of Rust's syntax.
After reading "Basics," you will have a good foundation to learn more about
Rust, and can write very simple programs.
In a similar fashion to "Intermediate," this section is full of individual,
deep-dive chapters, which stand alone and can be read in any order. These
-chapters focus on the most complex features, as well as some things that
-are only available in upcoming versions of Rust.
+chapters focus on the most complex features,
-After reading "Advanced," you'll be a Rust expert!
+<h2 class="section-header"><a href="unstable.html">Unstable</a></h2>
+
+In a similar fashion to "Intermediate," this section is full of individual,
+deep-dive chapters, which stand alone and can be read in any order.
+
+This chapter contains things that are only available on the nightly channel of
+Rust.
* [Looping](looping.md)
* [Strings](strings.md)
* [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md)
- * [Standard Input](standard-input.md)
* [Intermediate Rust](intermediate.md)
* [Crates and Modules](crates-and-modules.md)
* [Testing](testing.md)
* [FFI](ffi.md)
* [Unsafe Code](unsafe.md)
* [Advanced Macros](advanced-macros.md)
+* [Unstable Rust](unstable.md)
* [Compiler Plugins](plugins.md)
+ * [Inline Assembly](inline-assembly.md)
+ * [No stdlib](no-stdlib.md)
+ * [Intrinsics](intrinsics.md)
+ * [Lang items](lang-items.md)
+ * [Link args](link-args.md)
* [Conclusion](conclusion.md)
* [Glossary](glossary.md)
within Rust's macro system.
```rust
-#![feature(trace_macros)]
-
macro_rules! bct {
// cmd 0: d ... => ...
(0, $($ps:tt),* ; $_d:tt)
( $($ps:tt),* ; )
=> (());
}
-
-fn main() {
- trace_macros!(true);
-# /* just check the definition
- bct!(0, 0, 1, 1, 1 ; 1, 0, 1);
-# */
-}
```
Exercise: use macros to reduce duplication in the above definition of the
backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover
generics.
-We have now learned all of the most basic Rust concepts. We're ready to start
-building ourselves a guessing game, we just need to know one last thing: how to
-get input from the keyboard. You can't have a guessing game without the ability
-to guess!
+We have now learned all of the most basic Rust concepts.
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
-We can’t create a trait object like this, becuase we don’t know the associated
+We can’t create a trait object like this, because we don’t know the associated
types. Instead, we can write this:
```rust
% Basics
This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax, and cumulates
-in a small project: a guessing game.
+Rust. It has individual sections on each part of Rust's syntax.
After reading "Basics," you will have a good foundation to learn more about
Rust, and can write very simple programs.
[arity]: ./glossary.html#arity
[match]: ./match.html
-[game]: ./guessing-game.html#comparing-guesses
[generics]: ./generics.html
/// # }
/// ```
///
-/// ```should_fail
+/// ```should_panic
/// # #[macro_use] extern crate foo;
/// # fn main() {
/// panic_unless!(true == false, “I’m broken.”);
### Re-exports
-`rustdoc` will show the documentation for a publc re-export in both places:
+`rustdoc` will show the documentation for a public re-export in both places:
```ignore
extern crate foo;
crate `foo`, as well as the documentation for your crate. It will use the same
documentation in both places.
-This behavior can be supressed with `no_inline`:
+This behavior can be suppressed with `no_inline`:
```ignore
extern crate foo;
On OSX, frameworks behave with the same semantics as a dynamic library.
-## The `link_args` attribute
-
-There is one other way to tell rustc how to customize linking, and that is via
-the `link_args` attribute. This attribute is applied to `extern` blocks and
-specifies raw flags which need to get passed to the linker when producing an
-artifact. An example usage would be:
-
-``` no_run
-#![feature(link_args)]
-
-#[link_args = "-foo -bar -baz"]
-extern {}
-# fn main() {}
-```
-
-Note that this feature is currently hidden behind the `feature(link_args)` gate
-because this is not a sanctioned way of performing linking. Right now rustc
-shells out to the system linker, so it makes sense to provide extra command line
-arguments, but this will not always be the case. In the future rustc may use
-LLVM directly to link native libraries in which case `link_args` will have no
-meaning.
-
-It is highly recommended to *not* use this attribute, and rather use the more
-formal `#[link(...)]` attribute on `extern` blocks instead.
-
# Unsafe blocks
Some operations, like dereferencing unsafe pointers or calling functions that have been marked
this:
```
-unsafe fn kaboom(ptr: *const int) -> int { *ptr }
+unsafe fn kaboom(ptr: *const i32) -> i32 { *ptr }
```
This function can only be called from an `unsafe` block or another `unsafe` function.
fn main() {
println!("You have readline version {} installed.",
- rl_readline_version as int);
+ rl_readline_version as i32);
}
```
--- /dev/null
+% Inline Assembly
+
+For extremely low-level manipulations and performance reasons, one
+might wish to control the CPU directly. Rust supports using inline
+assembly to do this via the `asm!` macro. The syntax roughly matches
+that of GCC & Clang:
+
+```ignore
+asm!(assembly template
+ : output operands
+ : input operands
+ : clobbers
+ : options
+ );
+```
+
+Any use of `asm` is feature gated (requires `#![feature(asm)]` on the
+crate to allow) and of course requires an `unsafe` block.
+
+> **Note**: the examples here are given in x86/x86-64 assembly, but
+> all platforms are supported.
+
+## Assembly template
+
+The `assembly template` is the only required parameter and must be a
+literal string (i.e. `""`)
+
+```
+#![feature(asm)]
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+fn foo() {
+ unsafe {
+ asm!("NOP");
+ }
+}
+
+// other platforms
+#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+fn foo() { /* ... */ }
+
+fn main() {
+ // ...
+ foo();
+ // ...
+}
+```
+
+(The `feature(asm)` and `#[cfg]`s are omitted from now on.)
+
+Output operands, input operands, clobbers and options are all optional
+but you must add the right number of `:` if you skip them:
+
+```
+# #![feature(asm)]
+# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# fn main() { unsafe {
+asm!("xor %eax, %eax"
+ :
+ :
+ : "eax"
+ );
+# } }
+```
+
+Whitespace also doesn't matter:
+
+```
+# #![feature(asm)]
+# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# fn main() { unsafe {
+asm!("xor %eax, %eax" ::: "eax");
+# } }
+```
+
+## Operands
+
+Input and output operands follow the same format: `:
+"constraints1"(expr1), "constraints2"(expr2), ..."`. Output operand
+expressions must be mutable lvalues:
+
+```
+# #![feature(asm)]
+# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+fn add(a: i32, b: i32) -> i32 {
+ let mut c = 0;
+ unsafe {
+ asm!("add $2, $0"
+ : "=r"(c)
+ : "0"(a), "r"(b)
+ );
+ }
+ c
+}
+# #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+# fn add(a: i32, b: i32) -> i32 { a + b }
+
+fn main() {
+ assert_eq!(add(3, 14159), 14162)
+}
+```
+
+## Clobbers
+
+Some instructions modify registers which might otherwise have held
+different values so we use the clobbers list to indicate to the
+compiler not to assume any values loaded into those registers will
+stay valid.
+
+```
+# #![feature(asm)]
+# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+# fn main() { unsafe {
+// Put the value 0x200 in eax
+asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "eax");
+# } }
+```
+
+Input and output registers need not be listed since that information
+is already communicated by the given constraints. Otherwise, any other
+registers used either implicitly or explicitly should be listed.
+
+If the assembly changes the condition code register `cc` should be
+specified as one of the clobbers. Similarly, if the assembly modifies
+memory, `memory` should also be specified.
+
+## Options
+
+The last section, `options` is specific to Rust. The format is comma
+separated literal strings (i.e. `:"foo", "bar", "baz"`). It's used to
+specify some extra info about the inline assembly:
+
+Current valid options are:
+
+1. *volatile* - specifying this is analogous to
+ `__asm__ __volatile__ (...)` in gcc/clang.
+2. *alignstack* - certain instructions expect the stack to be
+ aligned a certain way (i.e. SSE) and specifying this indicates to
+ the compiler to insert its usual stack alignment code
+3. *intel* - use intel syntax instead of the default AT&T.
+
in the `$`s, they just indicate the start of each command):
```bash
-$ curl -L https://static.rust-lang.org/rustup.sh | sudo sh
+$ curl -sf -L https://static.rust-lang.org/rustup.sh | sudo sh
```
If you're concerned about the [potential insecurity](http://curlpipesh.tumblr.com/) of using `curl | sudo sh`,
please keep reading and see our disclaimer below. And feel free to use a two-step version of the installation and examine our installation script:
```bash
-$ curl -L https://static.rust-lang.org/rustup.sh -O
+$ curl -f -L https://static.rust-lang.org/rustup.sh -O
$ sudo sh rustup.sh
```
--- /dev/null
+% Intrinsics
+
+> **Note**: intrinsics will forever have an unstable interface, it is
+> recommended to use the stable interfaces of libcore rather than intrinsics
+> directly.
+
+These are imported as if they were FFI functions, with the special
+`rust-intrinsic` ABI. For example, if one was in a freestanding
+context, but wished to be able to `transmute` between types, and
+perform efficient pointer arithmetic, one would import those functions
+via a declaration like
+
+```
+# #![feature(intrinsics)]
+# fn main() {}
+
+extern "rust-intrinsic" {
+ fn transmute<T, U>(x: T) -> U;
+
+ fn offset<T>(dst: *const T, offset: isize) -> *const T;
+}
+```
+
+As with any other FFI functions, these are always `unsafe` to call.
+
--- /dev/null
+% Lang items
+
+> **Note**: lang items are often provided by crates in the Rust distribution,
+> and lang items themselves have an unstable interface. It is recommended to use
+> officially distributed crates instead of defining your own lang items.
+
+The `rustc` compiler has certain pluggable operations, that is,
+functionality that isn't hard-coded into the language, but is
+implemented in libraries, with a special marker to tell the compiler
+it exists. The marker is the attribute `#[lang="..."]` and there are
+various different values of `...`, i.e. various different 'lang
+items'.
+
+For example, `Box` pointers require two lang items, one for allocation
+and one for deallocation. A freestanding program that uses the `Box`
+sugar for dynamic allocations via `malloc` and `free`:
+
+```
+#![feature(lang_items, box_syntax, start, no_std, libc)]
+#![no_std]
+
+extern crate libc;
+
+extern {
+ fn abort() -> !;
+}
+
+#[lang = "owned_box"]
+pub struct Box<T>(*mut T);
+
+#[lang="exchange_malloc"]
+unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
+ let p = libc::malloc(size as libc::size_t) as *mut u8;
+
+ // malloc failed
+ if p as usize == 0 {
+ abort();
+ }
+
+ p
+}
+#[lang="exchange_free"]
+unsafe fn deallocate(ptr: *mut u8, _size: usize, _align: usize) {
+ libc::free(ptr as *mut libc::c_void)
+}
+
+#[start]
+fn main(argc: isize, argv: *const *const u8) -> isize {
+ let x = box 1;
+
+ 0
+}
+
+#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
+#[lang = "eh_personality"] extern fn eh_personality() {}
+#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
+```
+
+Note the use of `abort`: the `exchange_malloc` lang item is assumed to
+return a valid pointer, and so needs to do the check internally.
+
+Other features provided by lang items include:
+
+- overloadable operators via traits: the traits corresponding to the
+ `==`, `<`, dereferencing (`*`) and `+` (etc.) operators are all
+ marked with lang items; those specific four are `eq`, `ord`,
+ `deref`, and `add` respectively.
+- stack unwinding and general failure; the `eh_personality`, `fail`
+ and `fail_bounds_checks` lang items.
+- the traits in `std::marker` used to indicate types of
+ various kinds; lang items `send`, `sync` and `copy`.
+- the marker types and variance indicators found in
+ `std::marker`; lang items `covariant_type`,
+ `contravariant_lifetime`, etc.
+
+Lang items are loaded lazily by the compiler; e.g. if one never uses
+`Box` then there is no need to define functions for `exchange_malloc`
+and `exchange_free`. `rustc` will emit an error when an item is needed
+but not found in the current crate or any that it depends on.
--- /dev/null
+% Link args
+
+There is one other way to tell rustc how to customize linking, and that is via
+the `link_args` attribute. This attribute is applied to `extern` blocks and
+specifies raw flags which need to get passed to the linker when producing an
+artifact. An example usage would be:
+
+``` no_run
+#![feature(link_args)]
+
+#[link_args = "-foo -bar -baz"]
+extern {}
+# fn main() {}
+```
+
+Note that this feature is currently hidden behind the `feature(link_args)` gate
+because this is not a sanctioned way of performing linking. Right now rustc
+shells out to the system linker, so it makes sense to provide extra command line
+arguments, but this will not always be the case. In the future rustc may use
+LLVM directly to link native libraries in which case `link_args` will have no
+meaning.
+
+It is highly recommended to *not* use this attribute, and rather use the more
+formal `#[link(...)]` attribute on `extern` blocks instead.
+
iteration. This will only print the odd numbers:
```{rust}
-for x in 0u32..10 {
+for x in 0..10 {
if x % 2 == 0 { continue; }
println!("{}", x);
We've made a struct that represents a circle. We then write an `impl` block,
and inside it, define a method, `area`. Methods take a special first
-parameter, `&self`. There are three variants: `self`, `&self`, and `&mut self`.
+parameter, of which there are three variants: `self`, `&self`, and `&mut self`.
You can think of this first parameter as being the `x` in `x.foo()`. The three
variants correspond to the three kinds of thing `x` could be: `self` if it's
just a value on the stack, `&self` if it's a reference, and `&mut self` if it's
-a mutable reference. We should default to using `&self`, as it's the most
-common. Here's an example of all three variants:
+a mutable reference. We should default to using `&self`, as you should prefer
+borrowing over taking ownership, as well as taking immutable references
+over mutable ones. Here's an example of all three variants:
```rust
struct Circle {
std::f64::consts::PI * (self.radius * self.radius)
}
- fn grow(&self) -> Circle {
- Circle { x: self.x, y: self.y, radius: (self.radius * 10.0) }
+ fn grow(&self, increment: f64) -> Circle {
+ Circle { x: self.x, y: self.y, radius: self.radius + increment }
}
}
let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
println!("{}", c.area());
- let d = c.grow().area();
+ let d = c.grow(2.0).area();
println!("{}", d);
}
```
```
We just say we're returning a `Circle`. With this method, we can grow a new
-circle with an area that's 100 times larger than the old one.
+circle to any arbitrary size.
## Static methods
}
struct CircleBuilder {
- coordinate: f64,
+ x: f64,
+ y: f64,
radius: f64,
}
impl CircleBuilder {
fn new() -> CircleBuilder {
- CircleBuilder { coordinate: 0.0, radius: 0.0, }
+ CircleBuilder { x: 0.0, y: 0.0, radius: 0.0, }
+ }
+
+ fn x(&mut self, coordinate: f64) -> &mut CircleBuilder {
+ self.x = coordinate;
+ self
}
- fn coordinate(&mut self, coordinate: f64) -> &mut CircleBuilder {
- self.coordinate = coordinate;
+ fn y(&mut self, coordinate: f64) -> &mut CircleBuilder {
+ self.x = coordinate;
self
}
}
fn finalize(&self) -> Circle {
- Circle { x: self.coordinate, y: self.coordinate, radius: self.radius }
+ Circle { x: self.x, y: self.y, radius: self.radius }
}
}
fn main() {
let c = CircleBuilder::new()
- .coordinate(10.0)
- .radius(5.0)
+ .x(1.0)
+ .y(2.0)
+ .radius(2.0)
.finalize();
-
println!("area: {}", c.area());
+ println!("x: {}", c.x);
+ println!("y: {}", c.y);
}
```
To write a function that's generic over types of strings, use `&str`.
```
-fn some_string_length(x: &str) -> uint {
+fn some_string_length(x: &str) -> usize {
x.len()
}
--- /dev/null
+% No stdlib
+
+By default, `std` is linked to every Rust crate. In some contexts,
+this is undesirable, and can be avoided with the `#![no_std]`
+attribute attached to the crate.
+
+```ignore
+// a minimal library
+#![crate_type="lib"]
+#![feature(no_std)]
+#![no_std]
+# // fn main() {} tricked you, rustdoc!
+```
+
+Obviously there's more to life than just libraries: one can use
+`#[no_std]` with an executable, controlling the entry point is
+possible in two ways: the `#[start]` attribute, or overriding the
+default shim for the C `main` function with your own.
+
+The function marked `#[start]` is passed the command line parameters
+in the same format as C:
+
+```
+#![feature(lang_items, start, no_std, libc)]
+#![no_std]
+
+// Pull in the system libc library for what crt0.o likely requires
+extern crate libc;
+
+// Entry point for this program
+#[start]
+fn start(_argc: isize, _argv: *const *const u8) -> isize {
+ 0
+}
+
+// These functions and traits are used by the compiler, but not
+// for a bare-bones hello world. These are normally
+// provided by libstd.
+#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
+#[lang = "eh_personality"] extern fn eh_personality() {}
+#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
+# // fn main() {} tricked you, rustdoc!
+```
+
+To override the compiler-inserted `main` shim, one has to disable it
+with `#![no_main]` and then create the appropriate symbol with the
+correct ABI and the correct name, which requires overriding the
+compiler's name mangling too:
+
+```ignore
+#![feature(no_std)]
+#![no_std]
+#![no_main]
+#![feature(lang_items, start)]
+
+extern crate libc;
+
+#[no_mangle] // ensure that this symbol is called `main` in the output
+pub extern fn main(argc: i32, argv: *const *const u8) -> i32 {
+ 0
+}
+
+#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
+#[lang = "eh_personality"] extern fn eh_personality() {}
+#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
+# // fn main() {} tricked you, rustdoc!
+```
+
+
+The compiler currently makes a few assumptions about symbols which are available
+in the executable to call. Normally these functions are provided by the standard
+library, but without it you must define your own.
+
+The first of these three functions, `stack_exhausted`, is invoked whenever stack
+overflow is detected. This function has a number of restrictions about how it
+can be called and what it must do, but if the stack limit register is not being
+maintained then a thread always has an "infinite stack" and this function
+shouldn't get triggered.
+
+The second of these three functions, `eh_personality`, is used by the
+failure mechanisms of the compiler. This is often mapped to GCC's
+personality function (see the
+[libstd implementation](../std/rt/unwind/index.html) for more
+information), but crates which do not trigger a panic can be assured
+that this function is never called. The final function, `panic_fmt`, is
+also used by the failure mechanisms of the compiler.
+
+## Using libcore
+
+> **Note**: the core library's structure is unstable, and it is recommended to
+> use the standard library instead wherever possible.
+
+With the above techniques, we've got a bare-metal executable running some Rust
+code. There is a good deal of functionality provided by the standard library,
+however, that is necessary to be productive in Rust. If the standard library is
+not sufficient, then [libcore](../core/index.html) is designed to be used
+instead.
+
+The core library has very few dependencies and is much more portable than the
+standard library itself. Additionally, the core library has most of the
+necessary functionality for writing idiomatic and effective Rust code.
+
+As an example, here is a program that will calculate the dot product of two
+vectors provided from C, using idiomatic Rust practices.
+
+```
+#![feature(lang_items, start, no_std, core, libc)]
+#![no_std]
+
+# extern crate libc;
+extern crate core;
+
+use core::prelude::*;
+
+use core::mem;
+
+#[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]
+ // slice.
+ //
+ // This is an unsafe operation because the compiler
+ // cannot tell the pointers are valid.
+ let (a_slice, b_slice): (&[u32], &[u32]) = unsafe {
+ mem::transmute((
+ Slice { data: a, len: a_len as usize },
+ Slice { data: b, len: b_len as usize },
+ ))
+ };
+
+ // Iterate over the slices, collecting the result
+ let mut ret = 0;
+ for (i, j) in a_slice.iter().zip(b_slice.iter()) {
+ ret += (*i) * (*j);
+ }
+ return ret;
+}
+
+#[lang = "panic_fmt"]
+extern fn panic_fmt(args: &core::fmt::Arguments,
+ file: &str,
+ line: u32) -> ! {
+ loop {}
+}
+
+#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
+#[lang = "eh_personality"] extern fn eh_personality() {}
+# #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
+# fn main() {}
+```
+
+Note that there is one extra lang item here which differs from the examples
+above, `panic_fmt`. This must be defined by consumers of libcore because the
+core library declares panics, but it does not define it. The `panic_fmt`
+lang item is this crate's definition of panic, and it must be guaranteed to
+never return.
+
+As can be seen in this example, the core library is intended to provide the
+power of Rust in all circumstances, regardless of platform requirements. Further
+libraries, such as liballoc, add functionality to libcore which make other
+platform-specific assumptions, but continue to be more portable than the
+standard library itself.
+
## Lifetime Elision
-Earlier, we mentioned *lifetime elision*, a feature of Rust which allows you to
-not write lifetime annotations in certain circumstances. All references have a
-lifetime, and so if you elide a lifetime (like `&T` instead of `&'a T`), Rust
-will do three things to determine what those lifetimes should be.
+Rust supports powerful local type inference in function bodies, but it’s
+forbidden in item signatures to allow reasoning about the types just based in
+the item signature alone. However, for ergonomic reasons a very restricted
+secondary inference algorithm called “lifetime elision” applies in function
+signatures. It infers only based on the signature components themselves and not
+based on the body of the function, only infers lifetime paramters, and does
+this with only three easily memorizable and unambiguous rules. This makes
+lifetime elision a shorthand for writing an item signature, while not hiding
+away the actual types involved as full local inference would if applied to it.
When talking about lifetime elision, we use the term *input lifetime* and
*output lifetime*. An *input lifetime* is a lifetime associated with a parameter
If you want to match against a slice or array, you can use `&`:
```{rust}
+# #![feature(slice_patterns)]
fn main() {
let v = vec!["match_this", "1"];
% Compiler Plugins
-<div class="unstable-feature">
-
-<p>
-<b>Warning:</b> Plugins are an advanced, unstable feature! For many details,
-the only available documentation is the <a
-href="../syntax/index.html"><code>libsyntax</code></a> and <a
-href="../rustc/index.html"><code>librustc</code></a> API docs, or even the source
-code itself. These internal compiler APIs are also subject to change at any
-time.
-</p>
-
-<p>
-For defining new syntax it is often much easier to use Rust's <a
-href="macros.html">built-in macro system</a>.
-</p>
-
-<p style="margin-bottom: 0">
-The code in this document uses language features not covered in the Rust
-Guide. See the <a href="../reference.html">Reference Manual</a> for more
-information.
-</p>
-
-</div>
-
# Introduction
`rustc` can load compiler plugins, which are user-provided libraries that
fn main() {
let x = Box::new(5);
- println!("{}", add(&x, &x));
- println!("{}", add(&x, &x));
+ println!("{}", add(&*x, &*x));
+ println!("{}", add(&*x, &*x));
}
```
+++ /dev/null
-% Standard Input
-
-Getting input from the keyboard is pretty easy, but uses some things
-we haven't seen before. Here's a simple program that reads some input,
-and then prints it back out:
-
-```{rust,ignore}
-corefn main() {
- println!("Type something!");
-
- let input = std::old_io::stdin().read_line().ok().expect("Failed to read line");
-
- println!("{}", input);
-}
-```
-
-Let's go over these chunks, one by one:
-
-```{rust,ignore}
-std::old_io::stdin();
-```
-
-This calls a function, `stdin()`, that lives inside the `std::old_io` module. As
-you can imagine, everything in `std` is provided by Rust, the 'standard
-library.' We'll talk more about the module system later.
-
-Since writing the fully qualified name all the time is annoying, we can use
-the `use` statement to import it in:
-
-```{rust}
-# #![feature(old_io)]
-use std::old_io::stdin;
-
-stdin();
-```
-
-However, it's considered better practice to not import individual functions, but
-to import the module, and only use one level of qualification:
-
-```{rust}
-# #![feature(old_io)]
-use std::old_io;
-
-old_io::stdin();
-```
-
-Let's update our example to use this style:
-
-```{rust,ignore}
-use std::old_io;
-
-fn main() {
- println!("Type something!");
-
- let input = old_io::stdin().read_line().ok().expect("Failed to read line");
-
- println!("{}", input);
-}
-```
-
-Next up:
-
-```{rust,ignore}
-.read_line()
-```
-
-The `read_line()` method can be called on the result of `stdin()` to return
-a full line of input. Nice and easy.
-
-```{rust,ignore}
-.ok().expect("Failed to read line");
-```
-
-Do you remember this code?
-
-```{rust}
-enum OptionalInt {
- Value(i32),
- Missing,
-}
-
-fn main() {
- let x = OptionalInt::Value(5);
- let y = OptionalInt::Missing;
-
- match x {
- OptionalInt::Value(n) => println!("x is {}", n),
- OptionalInt::Missing => println!("x is missing!"),
- }
-
- match y {
- OptionalInt::Value(n) => println!("y is {}", n),
- OptionalInt::Missing => println!("y is missing!"),
- }
-}
-```
-
-We had to match each time to see if we had a value or not. In this case,
-though, we _know_ that `x` has a `Value`, but `match` forces us to handle
-the `missing` case. This is what we want 99% of the time, but sometimes, we
-know better than the compiler.
-
-Likewise, `read_line()` does not return a line of input. It _might_ return a
-line of input, though it might also fail to do so. This could happen if our program
-isn't running in a terminal, but as part of a cron job, or some other context
-where there's no standard input. Because of this, `read_line` returns a type
-very similar to our `OptionalInt`: an `IoResult<T>`. We haven't talked about
-`IoResult<T>` yet because it is the *generic* form of our `OptionalInt`.
-Until then, you can think of it as being the same thing, just for any type –
-not just `i32`s.
-
-Rust provides a method on these `IoResult<T>`s called `ok()`, which does the
-same thing as our `match` statement but assumes that we have a valid value.
-We then call `expect()` on the result, which will terminate our program if we
-don't have a valid value. In this case, if we can't get input, our program
-doesn't work, so we're okay with that. In most cases, we would want to handle
-the error case explicitly. `expect()` allows us to give an error message if
-this crash happens.
-
-We will cover the exact details of how all of this works later in the Guide in
-[Error Handling]. For now, this gives you enough of a basic understanding to
-work with.
-
-Back to the code we were working on! Here's a refresher:
-
-```{rust,ignore}
-use std::old_io;
-
-fn main() {
- println!("Type something!");
-
- let input = old_io::stdin().read_line().ok().expect("Failed to read line");
-
- println!("{}", input);
-}
-```
-
-With long lines like this, Rust gives you some flexibility with the whitespace.
-We _could_ write the example like this:
-
-```{rust,ignore}
-use std::old_io;
-
-fn main() {
- println!("Type something!");
-
- // here, we'll show the types at each step
-
- let input = old_io::stdin() // std::old_io::stdio::StdinReader
- .read_line() // IoResult<String>
- .ok() // Option<String>
- .expect("Failed to read line"); // String
-
- println!("{}", input);
-}
-```
-
-Sometimes, this makes things more readable – sometimes, less. Use your judgement
-here.
-
-That's all you need to get basic input from the standard input! It's not too
-complicated, but there are a number of small parts.
-
-
-[Error Handling]: ./error-handling.html
}
#[cfg(test)]
-mod tests {
+mod test {
use super::add_two;
#[test]
}
```
-There's a few changes here. The first is the introduction of a `mod tests` with
+There's a few changes here. The first is the introduction of a `mod test` with
a `cfg` attribute. The module allows us to group all of our tests together, and
to also define helper functions if needed, that don't become a part of the rest
of our crate. The `cfg` attribute only compiles our test code if we're
}
#[cfg(test)]
-mod tests {
+mod test {
use super::*;
#[test]
--- /dev/null
+% Tracing Macros
+
+The `trace_macros` feature allows you to use a special feature: tracing macro
+invocations.
+
+In the advanced macros chapter, we defined a `bct` macro:
+
+```rust
+macro_rules! bct {
+ // cmd 0: d ... => ...
+ (0, $($ps:tt),* ; $_d:tt)
+ => (bct!($($ps),*, 0 ; ));
+ (0, $($ps:tt),* ; $_d:tt, $($ds:tt),*)
+ => (bct!($($ps),*, 0 ; $($ds),*));
+
+ // cmd 1p: 1 ... => 1 ... p
+ (1, $p:tt, $($ps:tt),* ; 1)
+ => (bct!($($ps),*, 1, $p ; 1, $p));
+ (1, $p:tt, $($ps:tt),* ; 1, $($ds:tt),*)
+ => (bct!($($ps),*, 1, $p ; 1, $($ds),*, $p));
+
+ // cmd 1p: 0 ... => 0 ...
+ (1, $p:tt, $($ps:tt),* ; $($ds:tt),*)
+ => (bct!($($ps),*, 1, $p ; $($ds),*));
+
+ // halt on empty data string
+ ( $($ps:tt),* ; )
+ => (());
+}
+```
+
+This is pretty complex! we can see the output
+
+```rust,ignore
+#![feature(trace_macros)]
+
+macro_rules! bct {
+ // cmd 0: d ... => ...
+ (0, $($ps:tt),* ; $_d:tt)
+ => (bct!($($ps),*, 0 ; ));
+ (0, $($ps:tt),* ; $_d:tt, $($ds:tt),*)
+ => (bct!($($ps),*, 0 ; $($ds),*));
+
+ // cmd 1p: 1 ... => 1 ... p
+ (1, $p:tt, $($ps:tt),* ; 1)
+ => (bct!($($ps),*, 1, $p ; 1, $p));
+ (1, $p:tt, $($ps:tt),* ; 1, $($ds:tt),*)
+ => (bct!($($ps),*, 1, $p ; 1, $($ds),*, $p));
+
+ // cmd 1p: 0 ... => 0 ...
+ (1, $p:tt, $($ps:tt),* ; $($ds:tt),*)
+ => (bct!($($ps),*, 1, $p ; $($ds),*));
+
+ // halt on empty data string
+ ( $($ps:tt),* ; )
+ => (());
+}
+
+fn main() {
+ trace_macros!(true);
+
+ bct!(0, 0, 1, 1, 1 ; 1, 0, 1);
+}
+```
+
+This will print out a wall of text:
+
+```text
+bct! { 0 , 0 , 1 , 1 , 1 ; 1 , 0 , 1 }
+bct! { 0 , 1 , 1 , 1 , 0 ; 0 , 1 }
+bct! { 1 , 1 , 1 , 0 , 0 ; 1 }
+bct! { 1 , 0 , 0 , 1 , 1 ; 1 , 1 }
+bct! { 0 , 1 , 1 , 1 , 0 ; 1 , 1 , 0 }
+bct! { 1 , 1 , 1 , 0 , 0 ; 1 , 0 }
+bct! { 1 , 0 , 0 , 1 , 1 ; 1 , 0 , 1 }
+bct! { 0 , 1 , 1 , 1 , 0 ; 1 , 0 , 1 , 0 }
+bct! { 1 , 1 , 1 , 0 , 0 ; 0 , 1 , 0 }
+bct! { 1 , 0 , 0 , 1 , 1 ; 0 , 1 , 0 }
+bct! { 0 , 1 , 1 , 1 , 0 ; 0 , 1 , 0 }
+```
+
+And eventually, error:
+
+```text
+18:45 error: recursion limit reached while expanding the macro `bct`
+ => (bct!($($ps),*, 1, $p ; $($ds),*));
+ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+```
+
+The `trace_macros!` call is what produces this output, showing how we match
+each time.
}
let default = UseDefault;
-default.baz(); // prints "We called bar."
+default.baz(); // prints "We called baz."
let over = OverrideDefault;
over.baz(); // prints "Override baz!"
that clean-up is always run, even when the thread panics.
- ensure that any data stored behind a raw pointer is destroyed at the
appropriate time.
-
-As an example, we give a reimplementation of owned boxes by wrapping
-`malloc` and `free`. Rust's move semantics and lifetimes mean this
-reimplementation is as safe as the `Box` type.
-
-```
-# #![feature(libc)]
-#![feature(unsafe_destructor)]
-
-extern crate libc;
-use libc::{c_void, size_t, malloc, free};
-use std::mem;
-use std::ptr;
-
-// Define a wrapper around the handle returned by the foreign code.
-// Unique<T> has the same semantics as Box<T>
-//
-// NB: For simplicity and correctness, we require that T has kind Send
-// (owned boxes relax this restriction).
-pub struct Unique<T: Send> {
- // It contains a single raw, mutable pointer to the object in question.
- ptr: *mut T
-}
-
-// Implement methods for creating and using the values in the box.
-
-impl<T: Send> Unique<T> {
- pub fn new(value: T) -> Unique<T> {
- unsafe {
- let ptr = malloc(mem::size_of::<T>() as size_t) as *mut T;
- // we *need* valid pointer.
- assert!(!ptr.is_null());
- // `*ptr` is uninitialized, and `*ptr = value` would
- // attempt to destroy it `overwrite` moves a value into
- // this memory without attempting to drop the original
- // value.
- ptr::write(&mut *ptr, value);
- Unique{ptr: ptr}
- }
- }
-
- // the 'r lifetime results in the same semantics as `&*x` with
- // Box<T>
- pub fn borrow<'r>(&'r self) -> &'r T {
- // By construction, self.ptr is valid
- unsafe { &*self.ptr }
- }
-
- // the 'r lifetime results in the same semantics as `&mut *x` with
- // Box<T>
- pub fn borrow_mut<'r>(&'r mut self) -> &'r mut T {
- unsafe { &mut *self.ptr }
- }
-}
-
-// A key ingredient for safety, we associate a destructor with
-// Unique<T>, making the struct manage the raw pointer: when the
-// struct goes out of scope, it will automatically free the raw pointer.
-//
-// NB: This is an unsafe destructor; rustc will not normally allow
-// destructors to be associated with parameterized types (due to
-// historically failing to check them soundly). Note that the
-// `#[unsafe_destructor]` feature gate is currently required to use
-// unsafe destructors.
-#[unsafe_destructor]
-impl<T: Send> Drop for Unique<T> {
- fn drop(&mut self) {
- unsafe {
- // Copy the object out from the pointer onto the stack,
- // where it is covered by normal Rust destructor semantics
- // and cleans itself up, if necessary
- ptr::read(self.ptr);
-
- // clean-up our allocation
- free(self.ptr as *mut c_void)
- }
- }
-}
-
-// A comparison between the built-in `Box` and this reimplementation
-fn main() {
- {
- let mut x = Box::new(5);
- *x = 10;
- } // `x` is freed here
-
- {
- let mut y = Unique::new(5);
- *y.borrow_mut() = 10;
- } // `y` is freed here
-}
-```
-
-Notably, the only way to construct a `Unique` is via the `new`
-function, and this function ensures that the internal pointer is valid
-and hidden in the private field. The two `borrow` methods are safe
-because the compiler statically guarantees that objects are never used
-before creation or after destruction (unless you use some `unsafe`
-code...).
-
-# Inline assembly
-
-For extremely low-level manipulations and performance reasons, one
-might wish to control the CPU directly. Rust supports using inline
-assembly to do this via the `asm!` macro. The syntax roughly matches
-that of GCC & Clang:
-
-```ignore
-asm!(assembly template
- : output operands
- : input operands
- : clobbers
- : options
- );
-```
-
-Any use of `asm` is feature gated (requires `#![feature(asm)]` on the
-crate to allow) and of course requires an `unsafe` block.
-
-> **Note**: the examples here are given in x86/x86-64 assembly, but
-> all platforms are supported.
-
-## Assembly template
-
-The `assembly template` is the only required parameter and must be a
-literal string (i.e. `""`)
-
-```
-#![feature(asm)]
-
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn foo() {
- unsafe {
- asm!("NOP");
- }
-}
-
-// other platforms
-#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
-fn foo() { /* ... */ }
-
-fn main() {
- // ...
- foo();
- // ...
-}
-```
-
-(The `feature(asm)` and `#[cfg]`s are omitted from now on.)
-
-Output operands, input operands, clobbers and options are all optional
-but you must add the right number of `:` if you skip them:
-
-```
-# #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-# fn main() { unsafe {
-asm!("xor %eax, %eax"
- :
- :
- : "eax"
- );
-# } }
-```
-
-Whitespace also doesn't matter:
-
-```
-# #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-# fn main() { unsafe {
-asm!("xor %eax, %eax" ::: "eax");
-# } }
-```
-
-## Operands
-
-Input and output operands follow the same format: `:
-"constraints1"(expr1), "constraints2"(expr2), ..."`. Output operand
-expressions must be mutable lvalues:
-
-```
-# #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-fn add(a: i32, b: i32) -> i32 {
- let mut c = 0;
- unsafe {
- asm!("add $2, $0"
- : "=r"(c)
- : "0"(a), "r"(b)
- );
- }
- c
-}
-# #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
-# fn add(a: i32, b: i32) -> i32 { a + b }
-
-fn main() {
- assert_eq!(add(3, 14159), 14162)
-}
-```
-
-## Clobbers
-
-Some instructions modify registers which might otherwise have held
-different values so we use the clobbers list to indicate to the
-compiler not to assume any values loaded into those registers will
-stay valid.
-
-```
-# #![feature(asm)]
-# #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-# fn main() { unsafe {
-// Put the value 0x200 in eax
-asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "eax");
-# } }
-```
-
-Input and output registers need not be listed since that information
-is already communicated by the given constraints. Otherwise, any other
-registers used either implicitly or explicitly should be listed.
-
-If the assembly changes the condition code register `cc` should be
-specified as one of the clobbers. Similarly, if the assembly modifies
-memory, `memory` should also be specified.
-
-## Options
-
-The last section, `options` is specific to Rust. The format is comma
-separated literal strings (i.e. `:"foo", "bar", "baz"`). It's used to
-specify some extra info about the inline assembly:
-
-Current valid options are:
-
-1. *volatile* - specifying this is analogous to
- `__asm__ __volatile__ (...)` in gcc/clang.
-2. *alignstack* - certain instructions expect the stack to be
- aligned a certain way (i.e. SSE) and specifying this indicates to
- the compiler to insert its usual stack alignment code
-3. *intel* - use intel syntax instead of the default AT&T.
-
-# Avoiding the standard library
-
-By default, `std` is linked to every Rust crate. In some contexts,
-this is undesirable, and can be avoided with the `#![no_std]`
-attribute attached to the crate.
-
-```ignore
-// a minimal library
-#![crate_type="lib"]
-#![feature(no_std)]
-#![no_std]
-# // fn main() {} tricked you, rustdoc!
-```
-
-Obviously there's more to life than just libraries: one can use
-`#[no_std]` with an executable, controlling the entry point is
-possible in two ways: the `#[start]` attribute, or overriding the
-default shim for the C `main` function with your own.
-
-The function marked `#[start]` is passed the command line parameters
-in the same format as C:
-
-```
-# #![feature(libc)]
-#![feature(lang_items, start, no_std)]
-#![no_std]
-
-// Pull in the system libc library for what crt0.o likely requires
-extern crate libc;
-
-// Entry point for this program
-#[start]
-fn start(_argc: isize, _argv: *const *const u8) -> isize {
- 0
-}
-
-// These functions and traits are used by the compiler, but not
-// for a bare-bones hello world. These are normally
-// provided by libstd.
-#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
-#[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
-# // fn main() {} tricked you, rustdoc!
-```
-
-To override the compiler-inserted `main` shim, one has to disable it
-with `#![no_main]` and then create the appropriate symbol with the
-correct ABI and the correct name, which requires overriding the
-compiler's name mangling too:
-
-```ignore
-# #![feature(libc)]
-#![feature(no_std)]
-#![no_std]
-#![no_main]
-#![feature(lang_items, start)]
-
-extern crate libc;
-
-#[no_mangle] // ensure that this symbol is called `main` in the output
-pub extern fn main(argc: i32, argv: *const *const u8) -> i32 {
- 0
-}
-
-#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
-#[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
-# // fn main() {} tricked you, rustdoc!
-```
-
-
-The compiler currently makes a few assumptions about symbols which are available
-in the executable to call. Normally these functions are provided by the standard
-library, but without it you must define your own.
-
-The first of these three functions, `stack_exhausted`, is invoked whenever stack
-overflow is detected. This function has a number of restrictions about how it
-can be called and what it must do, but if the stack limit register is not being
-maintained then a thread always has an "infinite stack" and this function
-shouldn't get triggered.
-
-The second of these three functions, `eh_personality`, is used by the
-failure mechanisms of the compiler. This is often mapped to GCC's
-personality function (see the
-[libstd implementation](../std/rt/unwind/index.html) for more
-information), but crates which do not trigger a panic can be assured
-that this function is never called. The final function, `panic_fmt`, is
-also used by the failure mechanisms of the compiler.
-
-## Using libcore
-
-> **Note**: the core library's structure is unstable, and it is recommended to
-> use the standard library instead wherever possible.
-
-With the above techniques, we've got a bare-metal executable running some Rust
-code. There is a good deal of functionality provided by the standard library,
-however, that is necessary to be productive in Rust. If the standard library is
-not sufficient, then [libcore](../core/index.html) is designed to be used
-instead.
-
-The core library has very few dependencies and is much more portable than the
-standard library itself. Additionally, the core library has most of the
-necessary functionality for writing idiomatic and effective Rust code.
-
-As an example, here is a program that will calculate the dot product of two
-vectors provided from C, using idiomatic Rust practices.
-
-```
-# #![feature(libc, core)]
-#![feature(lang_items, start, no_std)]
-#![no_std]
-
-# extern crate libc;
-extern crate core;
-
-use core::prelude::*;
-
-use core::mem;
-
-#[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]
- // slice.
- //
- // This is an unsafe operation because the compiler
- // cannot tell the pointers are valid.
- let (a_slice, b_slice): (&[u32], &[u32]) = unsafe {
- mem::transmute((
- Slice { data: a, len: a_len as usize },
- Slice { data: b, len: b_len as usize },
- ))
- };
-
- // Iterate over the slices, collecting the result
- let mut ret = 0;
- for (i, j) in a_slice.iter().zip(b_slice.iter()) {
- ret += (*i) * (*j);
- }
- return ret;
-}
-
-#[lang = "panic_fmt"]
-extern fn panic_fmt(args: &core::fmt::Arguments,
- file: &str,
- line: u32) -> ! {
- loop {}
-}
-
-#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
-#[lang = "eh_personality"] extern fn eh_personality() {}
-# #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
-# fn main() {}
-```
-
-Note that there is one extra lang item here which differs from the examples
-above, `panic_fmt`. This must be defined by consumers of libcore because the
-core library declares panics, but it does not define it. The `panic_fmt`
-lang item is this crate's definition of panic, and it must be guaranteed to
-never return.
-
-As can be seen in this example, the core library is intended to provide the
-power of Rust in all circumstances, regardless of platform requirements. Further
-libraries, such as liballoc, add functionality to libcore which make other
-platform-specific assumptions, but continue to be more portable than the
-standard library itself.
-
-# Interacting with the compiler internals
-
-> **Note**: this section is specific to the `rustc` compiler; these
-> parts of the language may never be fully specified and so details may
-> differ wildly between implementations (and even versions of `rustc`
-> itself).
->
-> Furthermore, this is just an overview; the best form of
-> documentation for specific instances of these features are their
-> definitions and uses in `std`.
-
-The Rust language currently has two orthogonal mechanisms for allowing
-libraries to interact directly with the compiler and vice versa:
-
-- intrinsics, functions built directly into the compiler providing
- very basic low-level functionality,
-- lang-items, special functions, types and traits in libraries marked
- with specific `#[lang]` attributes
-
-## Intrinsics
-
-> **Note**: intrinsics will forever have an unstable interface, it is
-> recommended to use the stable interfaces of libcore rather than intrinsics
-> directly.
-
-These are imported as if they were FFI functions, with the special
-`rust-intrinsic` ABI. For example, if one was in a freestanding
-context, but wished to be able to `transmute` between types, and
-perform efficient pointer arithmetic, one would import those functions
-via a declaration like
-
-```
-# #![feature(intrinsics)]
-# fn main() {}
-
-extern "rust-intrinsic" {
- fn transmute<T, U>(x: T) -> U;
-
- fn offset<T>(dst: *const T, offset: isize) -> *const T;
-}
-```
-
-As with any other FFI functions, these are always `unsafe` to call.
-
-## Lang items
-
-> **Note**: lang items are often provided by crates in the Rust distribution,
-> and lang items themselves have an unstable interface. It is recommended to use
-> officially distributed crates instead of defining your own lang items.
-
-The `rustc` compiler has certain pluggable operations, that is,
-functionality that isn't hard-coded into the language, but is
-implemented in libraries, with a special marker to tell the compiler
-it exists. The marker is the attribute `#[lang="..."]` and there are
-various different values of `...`, i.e. various different 'lang
-items'.
-
-For example, `Box` pointers require two lang items, one for allocation
-and one for deallocation. A freestanding program that uses the `Box`
-sugar for dynamic allocations via `malloc` and `free`:
-
-```
-# #![feature(libc)]
-#![feature(lang_items, box_syntax, start, no_std)]
-#![no_std]
-
-extern crate libc;
-
-extern {
- fn abort() -> !;
-}
-
-#[lang = "owned_box"]
-pub struct Box<T>(*mut T);
-
-#[lang="exchange_malloc"]
-unsafe fn allocate(size: usize, _align: usize) -> *mut u8 {
- let p = libc::malloc(size as libc::size_t) as *mut u8;
-
- // malloc failed
- if p as usize == 0 {
- abort();
- }
-
- p
-}
-#[lang="exchange_free"]
-unsafe fn deallocate(ptr: *mut u8, _size: usize, _align: usize) {
- libc::free(ptr as *mut libc::c_void)
-}
-
-#[start]
-fn main(argc: isize, argv: *const *const u8) -> isize {
- let x = box 1;
-
- 0
-}
-
-#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
-#[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }
-```
-
-Note the use of `abort`: the `exchange_malloc` lang item is assumed to
-return a valid pointer, and so needs to do the check internally.
-
-Other features provided by lang items include:
-
-- overloadable operators via traits: the traits corresponding to the
- `==`, `<`, dereferencing (`*`) and `+` (etc.) operators are all
- marked with lang items; those specific four are `eq`, `ord`,
- `deref`, and `add` respectively.
-- stack unwinding and general failure; the `eh_personality`, `fail`
- and `fail_bounds_checks` lang items.
-- the traits in `std::marker` used to indicate types of
- various kinds; lang items `send`, `sync` and `copy`.
-- the marker types and variance indicators found in
- `std::marker`; lang items `covariant_type`,
- `contravariant_lifetime`, etc.
-
-Lang items are loaded lazily by the compiler; e.g. if one never uses
-`Box` then there is no need to define functions for `exchange_malloc`
-and `exchange_free`. `rustc` will emit an error when an item is needed
-but not found in the current crate or any that it depends on.
--- /dev/null
+% Unstable Rust
#![cfg_attr(rustdoc, feature(rustdoc))]
#[cfg(rustdoc)]
-extern crate "rustdoc" as this;
+extern crate rustdoc as this;
#[cfg(rustc)]
-extern crate "rustc_driver" as this;
+extern crate rustc_driver as this;
fn main() { this::main() }
MINGW32*)
CFG_OSTYPE=pc-mingw32
;;
-# Thad's Cygwin identifers below
+# Thad's Cygwin identifiers below
# Vista 32 bit
CYGWIN_NT-6.0)
|| create_tmp_dir)
# If we're saving nightlies and we didn't specify which one, grab the latest
-# verison from the perspective of the server. Buildbot has typically finished
+# version from the perspective of the server. Buildbot has typically finished
# building and uploading by ~8UTC, but we want to include a little buffer.
#
# FIXME It would be better to use the known most recent nightly that has been
//!
//! Sharing some immutable data between tasks:
//!
-//! ```
+//! ```no_run
//! use std::sync::Arc;
//! use std::thread;
//!
//!
//! Sharing mutable data safely between tasks with a `Mutex`:
//!
-//! ```
+//! ```no_run
//! use std::sync::{Arc, Mutex};
//! use std::thread;
//!
use core::atomic;
use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
use core::fmt;
-use core::cmp::{Ordering};
+use core::cmp::Ordering;
use core::default::Default;
use core::mem::{min_align_of, size_of};
use core::mem;
/// With simple pipes, without `Arc`, a copy would have to be made for each
/// task.
///
+/// When you clone an `Arc<T>`, it will create another pointer to the data and
+/// increase the reference counter.
+///
/// ```
/// # #![feature(alloc, core)]
/// use std::sync::Arc;
// more than once (but it is guaranteed to be zeroed after the first if
// it's run more than once)
let ptr = *self._ptr;
- if ptr.is_null() { return }
+ // if ptr.is_null() { return }
+ if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return }
// Because `fetch_sub` is already atomic, we do not need to synchronize
// with other threads unless we are going to delete the object. This
let ptr = *self._ptr;
// see comments above for why this check is here
- if ptr.is_null() { return }
+ if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return }
// If we find out that we were the last weak pointer, then its time to
// deallocate the data entirely. See the discussion in Arc::drop() about
/// Returns the boxed value if it is of type `T`, or
/// `Err(Self)` if it isn't.
#[stable(feature = "rust1", since = "1.0.0")]
- fn downcast<T:
'static>(self) -> Result<Box<T>, Box<Any>>;
+ fn downcast<T:
Any>(self) -> Result<Box<T>, Box<Any>>;
}
#[stable(feature = "rust1", since = "1.0.0")]
impl BoxAny for Box<Any> {
#[inline]
- fn downcast<T:
'static>(self) -> Result<Box<T>, Box<Any>> {
+ fn downcast<T:
Any>(self) -> Result<Box<T>, Box<Any>> {
if self.is::<T>() {
unsafe {
// Get the raw representation of the trait object
#[stable(feature = "rust1", since = "1.0.0")]
impl BoxAny for Box<Any+Send> {
#[inline]
- fn downcast<T:
'static>(self) -> Result<Box<T>, Box<Any>> {
+ fn downcast<T:
Any>(self) -> Result<Box<T>, Box<Any>> {
<Box<Any>>::downcast(self)
}
}
use core::option::Option;
use core::option::Option::None;
use core::ptr::{null_mut, null};
- use core::num::Int;
use libc::{c_char, c_int, c_void, size_t};
use super::MIN_ALIGN;
libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
} else {
let new_ptr = allocate(size, align);
- ptr::copy(new_ptr, ptr, cmp::min(size, old_size));
+ ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
deallocate(ptr, old_size, align);
new_ptr
}
#![feature(box_syntax)]
#![feature(optin_builtin_traits)]
#![feature(unboxed_closures)]
-#![feature(unsafe_no_drop_flag)]
+#![feature(unsafe_no_drop_flag, filling_drop)]
#![feature(core)]
#![feature(unique)]
#![cfg_attr(test, feature(test, alloc, rustc_private))]
use core::fmt;
use core::hash::{Hasher, Hash};
use core::marker;
-use core::mem::{min_align_of, size_of, forget};
+use core::mem::{self, min_align_of, size_of, forget};
use core::nonzero::NonZero;
use core::ops::{Deref, Drop};
use core::option::Option;
fn drop(&mut self) {
unsafe {
let ptr = *self._ptr;
- if !ptr.is_null() {
+ if !ptr.is_null() && ptr as usize != mem::POST_DROP_USIZE {
self.dec_strong();
if self.strong() == 0 {
ptr::read(&**self); // destroy the contained object
/// Makes a clone of the `Rc<T>`.
///
- /// This increases the strong reference count.
+ /// When you clone an `Rc<T>`, it will create another pointer to the data and
+ /// increase the strong reference counter.
///
/// # Examples
///
fn drop(&mut self) {
unsafe {
let ptr = *self._ptr;
- if !ptr.is_null() {
+ if !ptr.is_null() && ptr as usize != mem::POST_DROP_USIZE {
self.dec_weak();
// the weak count starts at 1, and will only go to zero if all
// the strong pointers have disappeared.
use core::iter::RandomAccessIterator;
use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
use core::iter::{self, FromIterator, IntoIterator};
-use core::num::Int;
use core::ops::Index;
use core::slice;
use core::{u8, u32, usize};
impl Index<usize> for BitVec {
type Output = bool;
-
- #[cfg(stage0)]
- #[inline]
- fn index(&self, i: &usize) -> &bool {
- if self.get(*i).expect("index out of bounds") {
- &TRUE
- } else {
- &FALSE
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, i: usize) -> &bool {
if self.get(i).expect("index out of bounds") {
use core::fmt::Debug;
use core::hash::{Hash, Hasher};
use core::iter::{Map, FromIterator, IntoIterator};
-use core::ops::{Index};
+use core::ops::Index;
use core::{iter, fmt, mem, usize};
use Bound::{self, Included, Excluded, Unbounded};
#[stable(feature = "rust1", since = "1.0.0")]
impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
-
- for (i, (k, v)) in self.iter().enumerate() {
- if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{:?}: {:?}", *k, *v));
- }
-
- write!(f, "}}")
- }
-}
-
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
- where K: Borrow<Q>, Q: Ord
-{
- type Output = V;
-
- #[inline]
- fn index(&self, key: &Q) -> &V {
- self.get(key).expect("no entry found for key")
+ self.iter().fold(f.debug_map(), |b, (k, v)| b.entry(k, v)).finish()
}
}
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
where K: Borrow<Q>, Q: Ord
#[unsafe_destructor]
impl<K, V> Drop for Node<K, V> {
fn drop(&mut self) {
- if self.keys.is_null() {
+ if self.keys.is_null() ||
+ (unsafe { self.keys.get() as *const K as usize == mem::POST_DROP_USIZE })
+ {
// Since we have #[unsafe_no_drop_flag], we have to watch
- // out for a null value being stored in self.keys. (Using
+ // out for the sentinel value being stored in self.keys. (Using
// null is technically a violation of the `Unique`
// requirements, though.)
return;
#[inline]
unsafe fn insert_kv(&mut self, index: usize, key: K, val: V) -> &mut V {
ptr::copy(
- self.keys_mut().as_mut_ptr().offset(index as isize + 1),
self.keys().as_ptr().offset(index as isize),
+ self.keys_mut().as_mut_ptr().offset(index as isize + 1),
self.len() - index
);
ptr::copy(
- self.vals_mut().as_mut_ptr().offset(index as isize + 1),
self.vals().as_ptr().offset(index as isize),
+ self.vals_mut().as_mut_ptr().offset(index as isize + 1),
self.len() - index
);
#[inline]
unsafe fn insert_edge(&mut self, index: usize, edge: Node<K, V>) {
ptr::copy(
- self.edges_mut().as_mut_ptr().offset(index as isize + 1),
self.edges().as_ptr().offset(index as isize),
+ self.edges_mut().as_mut_ptr().offset(index as isize + 1),
self.len() - index
);
ptr::write(self.edges_mut().get_unchecked_mut(index), edge);
let val = ptr::read(self.vals().get_unchecked(index));
ptr::copy(
- self.keys_mut().as_mut_ptr().offset(index as isize),
self.keys().as_ptr().offset(index as isize + 1),
+ self.keys_mut().as_mut_ptr().offset(index as isize),
self.len() - index - 1
);
ptr::copy(
- self.vals_mut().as_mut_ptr().offset(index as isize),
self.vals().as_ptr().offset(index as isize + 1),
+ self.vals_mut().as_mut_ptr().offset(index as isize),
self.len() - index - 1
);
let edge = ptr::read(self.edges().get_unchecked(index));
ptr::copy(
- self.edges_mut().as_mut_ptr().offset(index as isize),
self.edges().as_ptr().offset(index as isize + 1),
+ self.edges_mut().as_mut_ptr().offset(index as isize),
// index can be == len+1, so do the +1 first to avoid underflow.
(self.len() + 1) - index
);
right._len = self.len() / 2;
let right_offset = self.len() - right.len();
ptr::copy_nonoverlapping(
- right.keys_mut().as_mut_ptr(),
self.keys().as_ptr().offset(right_offset as isize),
+ right.keys_mut().as_mut_ptr(),
right.len()
);
ptr::copy_nonoverlapping(
- right.vals_mut().as_mut_ptr(),
self.vals().as_ptr().offset(right_offset as isize),
+ right.vals_mut().as_mut_ptr(),
right.len()
);
if !self.is_leaf() {
ptr::copy_nonoverlapping(
- right.edges_mut().as_mut_ptr(),
self.edges().as_ptr().offset(right_offset as isize),
+ right.edges_mut().as_mut_ptr(),
right.len() + 1
);
}
ptr::write(self.vals_mut().get_unchecked_mut(old_len), val);
ptr::copy_nonoverlapping(
- self.keys_mut().as_mut_ptr().offset(old_len as isize + 1),
right.keys().as_ptr(),
+ self.keys_mut().as_mut_ptr().offset(old_len as isize + 1),
right.len()
);
ptr::copy_nonoverlapping(
- self.vals_mut().as_mut_ptr().offset(old_len as isize + 1),
right.vals().as_ptr(),
+ self.vals_mut().as_mut_ptr().offset(old_len as isize + 1),
right.len()
);
if !self.is_leaf() {
ptr::copy_nonoverlapping(
- self.edges_mut().as_mut_ptr().offset(old_len as isize + 1),
right.edges().as_ptr(),
+ self.edges_mut().as_mut_ptr().offset(old_len as isize + 1),
right.len() + 1
);
}
}
/// Returns a sub-slice with elements starting with `min_key`.
- #[cfg(stage0)]
- pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
- // _______________
- // |_1_|_3_|_5_|_7_|
- // | | | | |
- // 0 0 1 1 2 2 3 3 4 index
- // | | | | |
- // \___|___|___|___/ slice_from(&0); pos = 0
- // \___|___|___/ slice_from(&2); pos = 1
- // |___|___|___/ slice_from(&3); pos = 1; result.head_is_edge = false
- // \___|___/ slice_from(&4); pos = 2
- // \___/ slice_from(&6); pos = 3
- // \|/ slice_from(&999); pos = 4
- let (pos, pos_is_kv) = self.search_linear(min_key);
- $NodeSlice {
- has_edges: self.has_edges,
- edges: if !self.has_edges {
- self.edges
- } else {
- self.edges.$index(&(pos ..))
- },
- keys: &self.keys[pos ..],
- vals: self.vals.$index(&(pos ..)),
- head_is_edge: !pos_is_kv,
- tail_is_edge: self.tail_is_edge,
- }
- }
-
- /// Returns a sub-slice with elements starting with `min_key`.
- #[cfg(not(stage0))]
pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
}
/// Returns a sub-slice with elements up to and including `max_key`.
- #[cfg(stage0)]
- pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
- // _______________
- // |_1_|_3_|_5_|_7_|
- // | | | | |
- // 0 0 1 1 2 2 3 3 4 index
- // | | | | |
- //\|/ | | | | slice_to(&0); pos = 0
- // \___/ | | | slice_to(&2); pos = 1
- // \___|___| | | slice_to(&3); pos = 1; result.tail_is_edge = false
- // \___|___/ | | slice_to(&4); pos = 2
- // \___|___|___/ | slice_to(&6); pos = 3
- // \___|___|___|___/ slice_to(&999); pos = 4
- let (pos, pos_is_kv) = self.search_linear(max_key);
- let pos = pos + if pos_is_kv { 1 } else { 0 };
- $NodeSlice {
- has_edges: self.has_edges,
- edges: if !self.has_edges {
- self.edges
- } else {
- self.edges.$index(&(.. (pos + 1)))
- },
- keys: &self.keys[..pos],
- vals: self.vals.$index(&(.. pos)),
- head_is_edge: self.head_is_edge,
- tail_is_edge: !pos_is_kv,
- }
- }
-
- /// Returns a sub-slice with elements up to and including `max_key`.
- #[cfg(not(stage0))]
pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Debug> Debug for BTreeSet<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
-
- for (i, x) in self.iter().enumerate() {
- if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{:?}", *x));
- }
-
- write!(f, "}}")
+ self.iter().fold(f.debug_set(), |b, e| b.entry(e)).finish()
}
}
use core::prelude::*;
use core::marker;
use core::fmt;
-use core::num::Int;
use core::iter::{FromIterator, IntoIterator};
use core::ops::{Sub, BitOr, BitAnd, BitXor};
#![doc(test(no_crate_inject))]
#![allow(trivial_casts)]
-#![allow(trivial_numeric_casts)]
#![feature(alloc)]
#![feature(box_syntax)]
#![feature(box_patterns)]
#![feature(unicode)]
#![feature(unsafe_destructor)]
#![feature(unique)]
-#![feature(unsafe_no_drop_flag)]
+#![feature(unsafe_no_drop_flag, filling_drop)]
#![feature(step_by)]
#![feature(str_char)]
#![feature(convert)]
+#![feature(slice_patterns)]
+#![feature(debug_builders)]
#![cfg_attr(test, feature(rand, rustc_private, test, hash, collections))]
#![cfg_attr(test, allow(deprecated))] // rand
#[stable(feature = "rust1", since = "1.0.0")]
impl<A: fmt::Debug> fmt::Debug for LinkedList<A> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "["));
-
- for (i, e) in self.iter().enumerate() {
- if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{:?}", *e));
- }
-
- write!(f, "]")
+ self.iter().fold(f.debug_list(), |b, e| b.entry(e)).finish()
}
}
#[cfg(test)]
mod test {
use std::clone::Clone;
- use std::iter::{Iterator, IteratorExt};
+ use std::iter::Iterator;
use std::option::Option::{Some, None, self};
use std::rand;
use std::thread;
//!
//! ## Iteration
//!
-//! The slices implement `IntoIterator`. The iterators of yield references
-//! to the slice elements.
+//! The slices implement `IntoIterator`. The iterator yields references to the
+//! slice elements.
//!
//! ```
//! let numbers = &[0, 1, 2];
//! iterators.
//! * Further methods that return iterators are `.split()`, `.splitn()`,
//! `.chunks()`, `.windows()` and more.
-
#![doc(primitive = "slice")]
#![stable(feature = "rust1", since = "1.0.0")]
use core::clone::Clone;
use core::cmp::Ordering::{self, Greater, Less};
use core::cmp::{self, Ord, PartialEq};
-use core::iter::{Iterator, IteratorExt};
+use core::iter::Iterator;
use core::iter::MultiplicativeIterator;
use core::marker::Sized;
use core::mem::size_of;
use core::mem;
+#[cfg(stage0)]
use core::num::wrapping::WrappingOps;
use core::ops::FnMut;
use core::option::Option::{self, Some, None};
use alloc::boxed::Box;
use core::clone::Clone;
#[cfg(test)]
- use core::iter::{Iterator, IteratorExt};
+ use core::iter::Iterator;
use core::mem;
#[cfg(test)]
use core::option::Option::{Some, None};
core_slice::SliceExt::get_mut(self, index)
}
- /// Work with `self` as a mut slice.
- /// Primarily intended for getting a &mut [T] from a [T; N].
- #[stable(feature = "rust1", since = "1.0.0")]
+ /// Deprecated: use `&mut s[..]` instead.
+ #[unstable(feature = "collections",
+ reason = "will be replaced by slice syntax")]
+ #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
+ #[allow(deprecated)]
pub fn as_mut_slice(&mut self) -> &mut [T] {
core_slice::SliceExt::as_mut_slice(self)
}
if i != j {
let tmp = ptr::read(read_ptr);
- ptr::copy(buf_v.offset(j + 1),
- &*buf_v.offset(j),
+ ptr::copy(&*buf_v.offset(j),
+ buf_v.offset(j + 1),
(i - j) as usize);
- ptr::copy_nonoverlapping(buf_v.offset(j), &tmp, 1);
+ ptr::copy_nonoverlapping(&tmp, buf_v.offset(j), 1);
mem::forget(tmp);
}
}
// j + 1 could be `len` (for the last `i`), but in
// that case, `i == j` so we don't copy. The
// `.offset(j)` is always in bounds.
- ptr::copy(buf_dat.offset(j + 1),
- &*buf_dat.offset(j),
+ ptr::copy(&*buf_dat.offset(j),
+ buf_dat.offset(j + 1),
i - j as usize);
- ptr::copy_nonoverlapping(buf_dat.offset(j), read_ptr, 1);
+ ptr::copy_nonoverlapping(read_ptr, buf_dat.offset(j), 1);
}
}
}
if left == right_start {
// the number remaining in this run.
let elems = (right_end as usize - right as usize) / mem::size_of::<T>();
- ptr::copy_nonoverlapping(out, &*right, elems);
+ ptr::copy_nonoverlapping(&*right, out, elems);
break;
} else if right == right_end {
let elems = (right_start as usize - left as usize) / mem::size_of::<T>();
- ptr::copy_nonoverlapping(out, &*left, elems);
+ ptr::copy_nonoverlapping(&*left, out, elems);
break;
}
} else {
step(&mut left)
};
- ptr::copy_nonoverlapping(out, &*to_copy, 1);
+ ptr::copy_nonoverlapping(&*to_copy, out, 1);
step(&mut out);
}
}
// write the result to `v` in one go, so that there are never two copies
// of the same object in `v`.
unsafe {
- ptr::copy_nonoverlapping(v.as_mut_ptr(), &*buf_dat, len);
+ ptr::copy_nonoverlapping(&*buf_dat, v.as_mut_ptr(), len);
}
// increment the pointer, returning the old pointer.
//! (see below). It is not possible to move out of borrowed strings because they
//! are owned elsewhere.
//!
-//! Basic operations are implemented directly by the compiler, but more advanced
-//! operations are defined as methods on the `str` type.
-//!
//! # Examples
//!
//! Here's some code that uses a `&str`:
use core::clone::Clone;
use core::iter::AdditiveIterator;
-use core::iter::{Iterator, IteratorExt, Extend};
+use core::iter::{Iterator, Extend};
use core::option::Option::{self, Some, None};
use core::result::Result;
use core::str as core_str;
let ch = self.char_at(idx);
let next = idx + ch.len_utf8();
unsafe {
- ptr::copy(self.vec.as_mut_ptr().offset(idx as isize),
- self.vec.as_ptr().offset(next as isize),
+ ptr::copy(self.vec.as_ptr().offset(next as isize),
+ self.vec.as_mut_ptr().offset(idx as isize),
len - next);
self.vec.set_len(len - (next - idx));
}
let amt = ch.encode_utf8(&mut bits).unwrap();
unsafe {
- ptr::copy(self.vec.as_mut_ptr().offset((idx + amt) as isize),
- self.vec.as_ptr().offset(idx as isize),
+ ptr::copy(self.vec.as_ptr().offset(idx as isize),
+ self.vec.as_mut_ptr().offset((idx + amt) as isize),
len - idx);
- ptr::copy(self.vec.as_mut_ptr().offset(idx as isize),
- bits.as_ptr(),
+ ptr::copy(bits.as_ptr(),
+ self.vec.as_mut_ptr().offset(idx as isize),
amt);
self.vec.set_len(len + amt);
}
impl ops::Index<ops::Range<usize>> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &str {
- &self[..][*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &str {
&self[..][index]
impl ops::Index<ops::RangeTo<usize>> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &str {
- &self[..][*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &str {
&self[..][index]
impl ops::Index<ops::RangeFrom<usize>> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
- &self[..][*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
&self[..][index]
impl ops::Index<ops::RangeFull> for String {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &str {
- unsafe { mem::transmute(&*self.vec) }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &str {
unsafe { mem::transmute(&*self.vec) }
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> From<&'a str> for String {
+ #[inline]
fn from(s: &'a str) -> String {
s.to_string()
}
}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a> From<&'a str> for Cow<'a, str> {
+ #[inline]
+ fn from(s: &'a str) -> Cow<'a, str> {
+ Cow::Borrowed(s)
+ }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a> From<String> for Cow<'a, str> {
+ #[inline]
+ fn from(s: String) -> Cow<'a, str> {
+ Cow::Owned(s)
+ }
+}
+
#[stable(feature = "rust1", since = "1.0.0")]
impl Into<Vec<u8>> for String {
fn into(self) -> Vec<u8> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`")]
impl IntoCow<'static, str> for String {
#[inline]
fn into_cow(self) -> Cow<'static, str> {
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
+#[unstable(feature = "into_cow", reason = "may be replaced by `convert::Into`")]
impl<'a> IntoCow<'a, str> for &'a str {
#[inline]
fn into_cow(self) -> Cow<'a, str> {
use alloc::boxed::Box;
use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
use core::cmp::max;
-use core::cmp::{Ordering};
+use core::cmp::Ordering;
use core::default::Default;
use core::fmt;
use core::hash::{self, Hash};
/// Creates a vector by copying the elements from a raw pointer.
///
- /// This function will copy `elts` contiguous elements starting at `ptr` into a new allocation
- /// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector
- /// without cloning, as if `ptr::read()` were called on them.
+ /// This function will copy `elts` contiguous elements starting at `ptr`
+ /// into a new allocation owned by the returned `Vec<T>`. The elements of
+ /// the buffer are copied into the vector without cloning, as if
+ /// `ptr::read()` were called on them.
#[inline]
#[unstable(feature = "collections",
reason = "may be better expressed via composition")]
pub unsafe fn from_raw_buf(ptr: *const T, elts: usize) -> Vec<T> {
let mut dst = Vec::with_capacity(elts);
dst.set_len(elts);
- ptr::copy_nonoverlapping(dst.as_mut_ptr(), ptr, elts);
+ ptr::copy_nonoverlapping(ptr, dst.as_mut_ptr(), elts);
dst
}
self.cap
}
- /// Reserves capacity for at least `additional` more elements to be inserted in the given
- /// `Vec<T>`. The collection may reserve more space to avoid frequent reallocations.
+ /// Reserves capacity for at least `additional` more elements to be inserted
+ /// in the given `Vec<T>`. The collection may reserve more space to avoid
+ /// frequent reallocations.
///
/// # Panics
///
}
}
- /// Returns a mutable slice of the elements of `self`.
- ///
- /// # Examples
- ///
- /// ```
- /// fn foo(slice: &mut [i32]) {}
- ///
- /// let mut vec = vec![1, 2];
- /// foo(vec.as_mut_slice());
- /// ```
+ /// Deprecated: use `&mut s[..]` instead.
#[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
+ #[unstable(feature = "collections",
+ reason = "will be replaced by slice syntax")]
+ #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
pub fn as_mut_slice(&mut self) -> &mut [T] {
- unsafe {
- let ptr = *self.ptr;
- assume(!ptr.is_null());
- slice::from_raw_parts_mut(ptr, self.len)
- }
+ &mut self[..]
}
/// Creates a consuming iterator, that is, one that moves each value out of
let p = self.as_mut_ptr().offset(index as isize);
// Shift everything over to make space. (Duplicating the
// `index`th element into two consecutive places.)
- ptr::copy(p.offset(1), &*p, len - index);
+ ptr::copy(&*p, p.offset(1), len - index);
// Write it in, overwriting the first copy of the `index`th
// element.
ptr::write(&mut *p, element);
ret = ptr::read(ptr);
// Shift everything down to fill in that spot.
- ptr::copy(ptr, &*ptr.offset(1), len - index - 1);
+ ptr::copy(&*ptr.offset(1), ptr, len - index - 1);
}
self.set_len(len - 1);
ret
let len = self.len();
unsafe {
ptr::copy_nonoverlapping(
- self.get_unchecked_mut(len),
other.as_ptr(),
+ self.get_unchecked_mut(len),
other.len());
}
other.set_len(other_len);
ptr::copy_nonoverlapping(
- other.as_mut_ptr(),
self.as_ptr().offset(at as isize),
+ other.as_mut_ptr(),
other.len());
}
other
impl<T> Index<usize> for Vec<T> {
type Output = T;
-
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &usize) -> &T {
- // NB built-in indexing via `&[T]`
- &(**self)[*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: usize) -> &T {
// NB built-in indexing via `&[T]`
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> IndexMut<usize> for Vec<T> {
-
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &usize) -> &mut T {
- // NB built-in indexing via `&mut [T]`
- &mut (**self)[*index]
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
// NB built-in indexing via `&mut [T]`
impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- Index::index(&**self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
Index::index(&**self, index)
impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- Index::index(&**self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
Index::index(&**self, index)
impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- Index::index(&**self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
Index::index(&**self, index)
impl<T> ops::Index<ops::RangeFull> for Vec<T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &[T] {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &[T] {
self
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
- IndexMut::index_mut(&mut **self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
- IndexMut::index_mut(&mut **self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
- IndexMut::index_mut(&mut **self, index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
- self.as_mut_slice()
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: ops::RangeFull) -> &mut [T] {
- self.as_mut_slice()
+ self
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::DerefMut for Vec<T> {
- fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() }
+ fn deref_mut(&mut self) -> &mut [T] {
+ unsafe {
+ let ptr = *self.ptr;
+ assume(!ptr.is_null());
+ slice::from_raw_parts_mut(ptr, self.len)
+ }
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
}
}
+#[unstable(feature = "collections",
+ reason = "will be replaced by slice syntax")]
+#[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
#[allow(deprecated)]
impl<T> AsSlice<T> for Vec<T> {
- /// Returns a slice into `self`.
- ///
- /// # Examples
- ///
- /// ```
- /// # #![feature(core)]
- /// fn foo(slice: &[i32]) {}
- ///
- /// let vec = vec![1, 2];
- /// foo(vec.as_slice());
- /// ```
+ /// Deprecated: use `&mut s[..]` instead.
#[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
fn as_slice(&self) -> &[T] {
self
}
fn drop(&mut self) {
// This is (and should always remain) a no-op if the fields are
// zeroed (when moving out, because of #[unsafe_no_drop_flag]).
- if self.cap != 0 {
+ if self.cap != 0 && self.cap != mem::POST_DROP_USIZE {
unsafe {
for x in &*self {
ptr::read(x);
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Drop for Drain<'a, T> {
fn drop(&mut self) {
- // self.ptr == self.end == null if drop has already been called,
+ // self.ptr == self.end == mem::POST_DROP_USIZE if drop has already been called,
// so we can use #[unsafe_no_drop_flag].
// destroy the remaining elements
use core::fmt;
use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator};
use core::mem;
+#[cfg(stage0)]
use core::num::wrapping::WrappingOps;
use core::ops::{Index, IndexMut};
use core::ptr::{self, Unique};
debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
ptr::copy(
- self.ptr.offset(dst as isize),
self.ptr.offset(src as isize),
+ self.ptr.offset(dst as isize),
len);
}
debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
self.cap);
ptr::copy_nonoverlapping(
- self.ptr.offset(dst as isize),
self.ptr.offset(src as isize),
+ self.ptr.offset(dst as isize),
len);
}
}
/// *num = *num - 2;
/// }
/// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
- /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[], b);
+ /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[..], b);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<T> {
// `at` lies in the first half.
let amount_in_first = first_len - at;
- ptr::copy_nonoverlapping(*other.ptr,
- first_half.as_ptr().offset(at as isize),
+ ptr::copy_nonoverlapping(first_half.as_ptr().offset(at as isize),
+ *other.ptr,
amount_in_first);
// just take all of the second half.
- ptr::copy_nonoverlapping(other.ptr.offset(amount_in_first as isize),
- second_half.as_ptr(),
+ ptr::copy_nonoverlapping(second_half.as_ptr(),
+ other.ptr.offset(amount_in_first as isize),
second_len);
} else {
// `at` lies in the second half, need to factor in the elements we skipped
// in the first half.
let offset = at - first_len;
let amount_in_second = second_len - offset;
- ptr::copy_nonoverlapping(*other.ptr,
- second_half.as_ptr().offset(offset as isize),
+ ptr::copy_nonoverlapping(second_half.as_ptr().offset(offset as isize),
+ *other.ptr,
amount_in_second);
}
}
impl<A> Index<usize> for VecDeque<A> {
type Output = A;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, i: &usize) -> &A {
- self.get(*i).expect("Out of bounds access")
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, i: usize) -> &A {
self.get(i).expect("Out of bounds access")
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> IndexMut<usize> for VecDeque<A> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, i: &usize) -> &mut A {
- self.get_mut(*i).expect("Out of bounds access")
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, i: usize) -> &mut A {
self.get_mut(i).expect("Out of bounds access")
#[cfg(test)]
mod test {
- use core::iter::{IteratorExt, self};
+ use core::iter::{Iterator, self};
use core::option::Option::Some;
use test;
}
}
-#[cfg(stage0)]
-impl<V> Index<usize> for VecMap<V> {
- type Output = V;
-
- #[inline]
- fn index<'a>(&'a self, i: &usize) -> &'a V {
- self.get(i).expect("key not present")
- }
-}
-
-#[cfg(not(stage0))]
impl<V> Index<usize> for VecMap<V> {
type Output = V;
}
}
-#[cfg(not(stage0))]
impl<'a,V> Index<&'a usize> for VecMap<V> {
type Output = V;
}
}
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<V> IndexMut<usize> for VecMap<V> {
- #[inline]
- fn index_mut(&mut self, i: &usize) -> &mut V {
- self.get_mut(&i).expect("key not present")
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> IndexMut<usize> for VecMap<V> {
#[inline]
}
}
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> IndexMut<&'a usize> for VecMap<V> {
#[inline]
let mut rng = rand::weak_rng();
for _ in 0..n {
- let i = rng.gen() % n;
+ let i = rng.gen::<usize>() % n;
map.insert(i, i);
}
// measure
b.iter(|| {
- let k = rng.gen() % n;
+ let k = rng.gen::<usize>() % n;
map.insert(k, k);
map.remove(&k);
});
($name: ident, $n: expr, $map: ident) => (
#[bench]
pub fn $name(b: &mut ::test::Bencher) {
- use std::iter::IteratorExt;
+ use std::iter::Iterator;
use std::rand::Rng;
use std::rand;
use std::vec::Vec;
// setup
let mut rng = rand::weak_rng();
- let mut keys: Vec<_> = (0..n).map(|_| rng.gen() % n).collect();
+ let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
for &k in &keys {
map.insert(k, k);
//! }
//!
//! // This function wants to log its parameter out prior to doing work with it.
-//! fn do_work<T: Debug + 'static>(value: &T) {
+//! fn do_work<T: Any + Debug>(value: &T) {
//! log(value);
//! // ...do some other work
//! }
use option::Option::{self, Some, None};
use raw::TraitObject;
use intrinsics;
-use marker::Sized;
+use marker::{Reflect, Sized};
///////////////////////////////////////////////////////////////////////////////
// Any trait
///
/// [mod]: ../index.html
#[stable(feature = "rust1", since = "1.0.0")]
-pub trait Any: 'static {
+pub trait Any: Reflect + 'static {
/// Get the `TypeId` of `self`
#[unstable(feature = "core",
reason = "this method will likely be replaced by an associated static")]
fn get_type_id(&self) -> TypeId;
}
-impl<T: 'static> Any for T {
+impl<T> Any for T
+ where T: Reflect + 'static
+{
fn get_type_id(&self) -> TypeId { TypeId::of::<T>() }
}
/// Returns true if the boxed type is the same as `T`
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn is<T: 'static>(&self) -> bool {
+ pub fn is<T: Any>(&self) -> bool {
// Get TypeId of the type this function is instantiated with
let t = TypeId::of::<T>();
/// `None` if it isn't.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
+ pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
if self.is::<T>() {
unsafe {
// Get the raw representation of the trait object
/// `None` if it isn't.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> {
+ pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {
if self.is::<T>() {
unsafe {
// Get the raw representation of the trait object
/// Forwards to the method defined on the type `Any`.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn is<T: 'static>(&self) -> bool {
+ pub fn is<T: Any>(&self) -> bool {
Any::is::<T>(self)
}
/// Forwards to the method defined on the type `Any`.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
+ pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
Any::downcast_ref::<T>(self)
}
/// Forwards to the method defined on the type `Any`.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> {
+ pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {
Any::downcast_mut::<T>(self)
}
}
/// instantiated with
#[unstable(feature = "core",
reason = "may grow a `Reflect` bound soon via marker traits")]
- pub fn of<T: ?Sized + 'static>() -> TypeId {
+ pub fn of<T: ?Sized + Any>() -> TypeId {
TypeId {
t: unsafe { intrinsics::type_id::<T>() },
}
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
+use convert::{AsRef, AsMut};
use fmt;
use hash::{Hash, self};
use iter::IntoIterator;
}
}
+ #[unstable(feature = "array_as_ref",
+ reason = "should ideally be implemented for all fixed-sized arrays")]
+ impl<T> AsRef<[T]> for [T; $N] {
+ #[inline]
+ fn as_ref(&self) -> &[T] {
+ &self[..]
+ }
+ }
+
+ #[unstable(feature = "array_as_ref",
+ reason = "should ideally be implemented for all fixed-sized arrays")]
+ impl<T> AsMut<[T]> for [T; $N] {
+ #[inline]
+ fn as_mut(&mut self) -> &mut [T] {
+ &mut self[..]
+ }
+ }
+
#[stable(feature = "rust1", since = "1.0.0")]
impl<T:Copy> Clone for [T; $N] {
fn clone(&self) -> [T; $N] {
/// Stores a value into the bool if the current value is the same as the expected value.
///
- /// If the return value is equal to `old` then the value was updated.
+ /// The return value is always the previous value. If it is equal to `old`, then the value was
+ /// updated.
///
/// `swap` also takes an `Ordering` argument which describes the memory ordering of this
/// operation.
/// Stores a value into the isize if the current value is the same as the expected value.
///
- /// If the return value is equal to `old` then the value was updated.
+ /// The return value is always the previous value. If it is equal to `old`, then the value was
+ /// updated.
///
/// `compare_and_swap` also takes an `Ordering` argument which describes the memory ordering of
/// this operation.
/// Stores a value into the usize if the current value is the same as the expected value.
///
- /// If the return value is equal to `old` then the value was updated.
+ /// The return value is always the previous value. If it is equal to `old`, then the value was
+ /// updated.
///
/// `compare_and_swap` also takes an `Ordering` argument which describes the memory ordering of
/// this operation.
/// Stores a value into the pointer if the current value is the same as the expected value.
///
- /// If the return value is equal to `old` then the value was updated.
+ /// The return value is always the previous value. If it is equal to `old`, then the value was
+ /// updated.
///
/// `compare_and_swap` also takes an `Ordering` argument which describes the memory ordering of
/// this operation.
reason = "renamed to AtomicIsize")]
#[allow(missing_docs)]
pub struct AtomicInt {
- v: UnsafeCell<int>,
+ v: UnsafeCell<isize>,
}
#[allow(deprecated)]
reason = "renamed to AtomicUsize")]
#[allow(missing_docs)]
pub struct AtomicUint {
- v: UnsafeCell<uint>,
+ v: UnsafeCell<usize>,
}
#[allow(deprecated)]
#[allow(missing_docs, deprecated)]
impl AtomicInt {
#[inline]
- pub fn new(v: int) -> AtomicInt {
+ pub fn new(v: isize) -> AtomicInt {
AtomicInt {v: UnsafeCell::new(v)}
}
#[inline]
- pub fn load(&self, order: Ordering) -> int {
+ pub fn load(&self, order: Ordering) -> isize {
unsafe { atomic_load(self.v.get(), order) }
}
#[inline]
- pub fn store(&self, val: int, order: Ordering) {
+ pub fn store(&self, val: isize, order: Ordering) {
unsafe { atomic_store(self.v.get(), val, order); }
}
#[inline]
- pub fn swap(&self, val: int, order: Ordering) -> int {
+ pub fn swap(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_swap(self.v.get(), val, order) }
}
#[inline]
- pub fn compare_and_swap(&self, old: int, new: int, order: Ordering) -> int {
+ pub fn compare_and_swap(&self, old: isize, new: isize, order: Ordering) -> isize {
unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) }
}
#[inline]
- pub fn fetch_add(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_add(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_add(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_sub(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_sub(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_sub(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_and(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_and(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_and(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_or(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_or(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_or(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_xor(&self, val: int, order: Ordering) -> int {
+ pub fn fetch_xor(&self, val: isize, order: Ordering) -> isize {
unsafe { atomic_xor(self.v.get(), val, order) }
}
}
#[allow(missing_docs, deprecated)]
impl AtomicUint {
#[inline]
- pub fn new(v: uint) -> AtomicUint {
+ pub fn new(v: usize) -> AtomicUint {
AtomicUint { v: UnsafeCell::new(v) }
}
#[inline]
- pub fn load(&self, order: Ordering) -> uint {
+ pub fn load(&self, order: Ordering) -> usize {
unsafe { atomic_load(self.v.get(), order) }
}
#[inline]
- pub fn store(&self, val: uint, order: Ordering) {
+ pub fn store(&self, val: usize, order: Ordering) {
unsafe { atomic_store(self.v.get(), val, order); }
}
#[inline]
- pub fn swap(&self, val: uint, order: Ordering) -> uint {
+ pub fn swap(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_swap(self.v.get(), val, order) }
}
#[inline]
- pub fn compare_and_swap(&self, old: uint, new: uint, order: Ordering) -> uint {
+ pub fn compare_and_swap(&self, old: usize, new: usize, order: Ordering) -> usize {
unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) }
}
#[inline]
- pub fn fetch_add(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_add(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_add(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_sub(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_sub(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_sub(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_and(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_and(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_and(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_or(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_or(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_or(self.v.get(), val, order) }
}
#[inline]
- pub fn fetch_xor(&self, val: uint, order: Ordering) -> uint {
+ pub fn fetch_xor(&self, val: usize, order: Ordering) -> usize {
unsafe { atomic_xor(self.v.get(), val, order) }
}
}
//!
//! ```
//! # #![feature(core)]
-//! use std::num::SignedInt;
-//!
//! struct FuzzyNum {
//! num: i32,
//! }
}
}
+// FIXME (#23442): replace the above impls for &/&mut with the following more general one:
+// // As lifts over Deref
+// impl<D: ?Sized + Deref, U: ?Sized> AsRef<U> for D where D::Target: AsRef<U> {
+// fn as_ref(&self) -> &U {
+// self.deref().as_ref()
+// }
+// }
+
// AsMut implies Into
impl<'a, T: ?Sized, U: ?Sized> Into<&'a mut U> for &'a mut T where T: AsMut<U> {
fn into(self) -> &'a mut U {
}
}
+// FIXME (#23442): replace the above impl for &mut with the following more general one:
+// // AsMut lifts over DerefMut
+// impl<D: ?Sized + Deref, U: ?Sized> AsMut<U> for D where D::Target: AsMut<U> {
+// fn as_mut(&mut self) -> &mut U {
+// self.deref_mut().as_mut()
+// }
+// }
+
// From implies Into
impl<T, U> Into<U> for T where U: From<T> {
fn into(self) -> U {
//! For example,
//!
//! ```
-//! # #![feature(os, old_io, old_path)]
+//! #![feature(core)]
//! use std::error::FromError;
-//! use std::old_io::{File, IoError};
-//! use std::os::{MemoryMap, MapError};
-//! use std::old_path::Path;
+//! use std::{io, str};
+//! use std::fs::File;
//!
//! enum MyError {
-//! Io(IoError),
-//! Map(MapError)
+//! Io(io::Error),
+//! Utf8(str::Utf8Error),
//! }
//!
-//! impl FromError<IoError> for MyError {
-//! fn from_error(err: IoError) -> MyError {
-//! MyError::Io(err)
-//! }
+//! impl FromError<io::Error> for MyError {
+//! fn from_error(err: io::Error) -> MyError { MyError::Io(err) }
//! }
//!
-//! impl FromError<MapError> for MyError {
-//! fn from_error(err: MapError) -> MyError {
-//! MyError::Map(err)
-//! }
+//! impl FromError<str::Utf8Error> for MyError {
+//! fn from_error(err: str::Utf8Error) -> MyError { MyError::Utf8(err) }
//! }
//!
//! #[allow(unused_variables)]
//! fn open_and_map() -> Result<(), MyError> {
-//! let f = try!(File::open(&Path::new("foo.txt")));
-//! let m = try!(MemoryMap::new(0, &[]));
+//! let b = b"foo.txt";
+//! let s = try!(str::from_utf8(b));
+//! let f = try!(File::open(s));
+//!
//! // do something interesting here...
//! Ok(())
//! }
/// Base functionality for all errors in Rust.
#[stable(feature = "rust1", since = "1.0.0")]
-pub trait Error: Debug + Display + Send {
+pub trait Error: Debug + Display {
/// A short description of the error.
///
/// The description should not contain newlines or sentence-ending
}
}
+struct DebugInner<'a, 'b: 'a> {
+ fmt: &'a mut fmt::Formatter<'b>,
+ result: fmt::Result,
+ has_fields: bool,
+}
+
+impl<'a, 'b: 'a> DebugInner<'a, 'b> {
+ fn entry(&mut self, entry: &fmt::Debug) {
+ self.result = self.result.and_then(|_| {
+ if self.is_pretty() {
+ let mut writer = PadAdapter::new(self.fmt);
+ let prefix = if self.has_fields { "," } else { "" };
+ fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
+ } else {
+ let prefix = if self.has_fields { ", " } else { "" };
+ write!(self.fmt, "{}{:?}", prefix, entry)
+ }
+ });
+
+ self.has_fields = true;
+ }
+
+ pub fn finish(&mut self) {
+ let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
+ self.result = self.result.and_then(|_| self.fmt.write_str(prefix));
+ }
+
+ fn is_pretty(&self) -> bool {
+ self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
+ }
+}
+
/// A struct to help with `fmt::Debug` implementations.
///
/// Constructed by the `Formatter::debug_set` method.
#[must_use]
pub struct DebugSet<'a, 'b: 'a> {
- fmt: &'a mut fmt::Formatter<'b>,
- result: fmt::Result,
- has_fields: bool,
+ inner: DebugInner<'a, 'b>,
}
-pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> DebugSet<'a, 'b> {
- let result = write!(fmt, "{} {{", name);
+pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b> {
+ let result = write!(fmt, "{{");
DebugSet {
- fmt: fmt,
- result: result,
- has_fields: false,
+ inner: DebugInner {
+ fmt: fmt,
+ result: result,
+ has_fields: false,
+ }
}
}
/// Adds a new entry to the set output.
#[unstable(feature = "debug_builders", reason = "method was just created")]
pub fn entry(mut self, entry: &fmt::Debug) -> DebugSet<'a, 'b> {
- self.result = self.result.and_then(|_| {
- let prefix = if self.has_fields {
- ","
- } else {
- ""
- };
-
- if self.is_pretty() {
- let mut writer = PadAdapter::new(self.fmt);
- fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
- } else {
- write!(self.fmt, "{} {:?}", prefix, entry)
- }
- });
-
- self.has_fields = true;
+ self.inner.entry(entry);
self
}
/// Consumes the `DebugSet`, finishing output and returning any error
/// encountered.
#[unstable(feature = "debug_builders", reason = "method was just created")]
- pub fn finish(self) -> fmt::Result {
- self.result.and_then(|_| {
- let end = match (self.has_fields, self.is_pretty()) {
- (false, _) => "}",
- (true, false) => " }",
- (true, true) => "\n}",
- };
- self.fmt.write_str(end)
- })
+ pub fn finish(mut self) -> fmt::Result {
+ self.inner.finish();
+ self.inner.result.and_then(|_| self.inner.fmt.write_str("}"))
}
+}
- fn is_pretty(&self) -> bool {
- self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
+/// A struct to help with `fmt::Debug` implementations.
+///
+/// Constructed by the `Formatter::debug_list` method.
+#[must_use]
+pub struct DebugList<'a, 'b: 'a> {
+ inner: DebugInner<'a, 'b>,
+}
+
+pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a, 'b> {
+ let result = write!(fmt, "[");
+ DebugList {
+ inner: DebugInner {
+ fmt: fmt,
+ result: result,
+ has_fields: false,
+ }
+ }
+}
+
+impl<'a, 'b: 'a> DebugList<'a, 'b> {
+ /// Adds a new entry to the set output.
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
+ pub fn entry(mut self, entry: &fmt::Debug) -> DebugList<'a, 'b> {
+ self.inner.entry(entry);
+ self
+ }
+
+ /// Consumes the `DebugSet`, finishing output and returning any error
+ /// encountered.
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
+ pub fn finish(mut self) -> fmt::Result {
+ self.inner.finish();
+ self.inner.result.and_then(|_| self.inner.fmt.write_str("]"))
}
}
has_fields: bool,
}
-pub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> DebugMap<'a, 'b> {
- let result = write!(fmt, "{} {{", name);
+pub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugMap<'a, 'b> {
+ let result = write!(fmt, "{{");
DebugMap {
fmt: fmt,
result: result,
#[unstable(feature = "debug_builders", reason = "method was just created")]
pub fn entry(mut self, key: &fmt::Debug, value: &fmt::Debug) -> DebugMap<'a, 'b> {
self.result = self.result.and_then(|_| {
- let prefix = if self.has_fields {
- ","
- } else {
- ""
- };
-
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
+ let prefix = if self.has_fields { "," } else { "" };
fmt::write(&mut writer, format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
} else {
- write!(self.fmt, "{} {:?}: {:?}", prefix, key, value)
+ let prefix = if self.has_fields { ", " } else { "" };
+ write!(self.fmt, "{}{:?}: {:?}", prefix, key, value)
}
});
self.has_fields = true;
-
self
}
/// encountered.
#[unstable(feature = "debug_builders", reason = "method was just created")]
pub fn finish(self) -> fmt::Result {
- self.result.and_then(|_| {
- let end = match (self.has_fields, self.is_pretty()) {
- (false, _) => "}",
- (true, false) => " }",
- (true, true) => "\n}",
- };
- self.fmt.write_str(end)
- })
+ let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
+ self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))
}
fn is_pretty(&self) -> bool {
use char;
use char::CharExt;
use fmt;
-use iter::IteratorExt;
+use iter::Iterator;
use num::{cast, Float, ToPrimitive};
use num::FpCategory as Fp;
use ops::FnOnce;
// otherwise as well.
let mut buf = [0; 1536];
let mut end = 0;
- let radix_gen: T = cast(radix as int).unwrap();
+ let radix_gen: T = cast(radix as isize).unwrap();
let (num, exp) = match exp_format {
ExpNone => (num, 0),
let extra_digit = ascii2value(buf[end - 1]);
end -= 1;
if extra_digit >= radix / 2 { // -> need to round
- let mut i: int = end as int - 1;
+ let mut i: isize = end as isize - 1;
loop {
// If reached left end of number, have to
// insert additional digit:
impl<'a> fmt::Write for Filler<'a> {
fn write_str(&mut self, s: &str) -> fmt::Result {
- slice::bytes::copy_memory(&mut self.buf[(*self.end)..],
- s.as_bytes());
+ slice::bytes::copy_memory(s.as_bytes(),
+ &mut self.buf[(*self.end)..]);
*self.end += s.len();
Ok(())
}
use any;
use cell::{Cell, RefCell, Ref, RefMut, BorrowState};
use char::CharExt;
-use iter::{Iterator, IteratorExt};
+use iter::Iterator;
use marker::{Copy, PhantomData, Sized};
use mem;
use option::Option;
pub use self::num::Radix;
pub use self::num::RadixFmt;
-pub use self::builders::{DebugStruct, DebugTuple, DebugSet, DebugMap};
+pub use self::builders::{DebugStruct, DebugTuple, DebugSet, DebugList, DebugMap};
mod num;
mod float;
/// // prints "Foo { bar: 10, baz: "Hello World" }"
/// println!("{:?}", Foo { bar: 10, baz: "Hello World".to_string() });
/// ```
- #[unstable(feature = "core", reason = "method was just created")]
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
#[inline]
pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a> {
builders::debug_struct_new(self, name)
/// // prints "Foo(10, "Hello World")"
/// println!("{:?}", Foo(10, "Hello World".to_string()));
/// ```
- #[unstable(feature = "core", reason = "method was just created")]
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
#[inline]
pub fn debug_tuple<'b>(&'b mut self, name: &str) -> DebugTuple<'b, 'a> {
builders::debug_tuple_new(self, name)
}
+ /// Creates a `DebugList` builder designed to assist with creation of
+ /// `fmt::Debug` implementations for list-like structures.
+ ///
+ /// # Examples
+ ///
+ /// ```rust
+ /// # #![feature(debug_builders, core)]
+ /// use std::fmt;
+ ///
+ /// struct Foo(Vec<i32>);
+ ///
+ /// impl fmt::Debug for Foo {
+ /// fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ /// self.0.iter().fold(fmt.debug_list(), |b, e| b.entry(e)).finish()
+ /// }
+ /// }
+ ///
+ /// // prints "[10, 11]"
+ /// println!("{:?}", Foo(vec![10, 11]));
+ /// ```
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
+ #[inline]
+ pub fn debug_list<'b>(&'b mut self) -> DebugList<'b, 'a> {
+ builders::debug_list_new(self)
+ }
+
/// Creates a `DebugSet` builder designed to assist with creation of
/// `fmt::Debug` implementations for set-like structures.
///
///
/// impl fmt::Debug for Foo {
/// fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- /// let mut builder = fmt.debug_set("Foo");
- /// for i in &self.0 {
- /// builder = builder.entry(i);
- /// }
- /// builder.finish()
+ /// self.0.iter().fold(fmt.debug_set(), |b, e| b.entry(e)).finish()
/// }
/// }
///
- /// // prints "Foo { 10, 11 }"
+ /// // prints "{10, 11}"
/// println!("{:?}", Foo(vec![10, 11]));
/// ```
- #[unstable(feature = "core", reason = "method was just created")]
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
#[inline]
- pub fn debug_set<'b>(&'b mut self, name: &str) -> DebugSet<'b, 'a> {
- builders::debug_set_new(self, name)
+ pub fn debug_set<'b>(&'b mut self) -> DebugSet<'b, 'a> {
+ builders::debug_set_new(self)
}
/// Creates a `DebugMap` builder designed to assist with creation of
///
/// impl fmt::Debug for Foo {
/// fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- /// let mut builder = fmt.debug_map("Foo");
- /// for &(ref key, ref value) in &self.0 {
- /// builder = builder.entry(key, value);
- /// }
- /// builder.finish()
+ /// self.0.iter().fold(fmt.debug_map(), |b, &(ref k, ref v)| b.entry(k, v)).finish()
/// }
/// }
///
- /// // prints "Foo { "A": 10, "B": 11 }"
+ /// // prints "{"A": 10, "B": 11}"
/// println!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)]));
/// ```
- #[unstable(feature = "core", reason = "method was just created")]
+ #[unstable(feature = "debug_builders", reason = "method was just created")]
#[inline]
- pub fn debug_map<'b>(&'b mut self, name: &str) -> DebugMap<'b, 'a> {
- builders::debug_map_new(self, name)
+ pub fn debug_map<'b>(&'b mut self) -> DebugMap<'b, 'a> {
+ builders::debug_map_new(self)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Debug> Debug for [T] {
fn fmt(&self, f: &mut Formatter) -> Result {
- if f.flags & (1 << (FlagV1::Alternate as u32)) == 0 {
- try!(write!(f, "["));
- }
- let mut is_first = true;
- for x in self {
- if is_first {
- is_first = false;
- } else {
- try!(write!(f, ", "));
- }
- try!(write!(f, "{:?}", *x))
- }
- if f.flags & (1 << (FlagV1::Alternate as u32)) == 0 {
- try!(write!(f, "]"));
- }
- Ok(())
+ self.iter().fold(f.debug_list(), |b, e| b.entry(e)).finish()
}
}
// FIXME: #6220 Implement floating point formatting
#![allow(unsigned_negation)]
-#![allow(trivial_numeric_casts)]
use fmt;
-use iter::IteratorExt;
+use iter::Iterator;
use num::{Int, cast};
use slice::SliceExt;
use str;
fn digit(&self, x: u8) -> u8;
/// Format an integer using the radix using a formatter.
+ #[allow(deprecated)] // Int
fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
// The radix can be as low as 2, so we need a buffer of at least 64
// characters for a base 2 number.
///
/// The `H` type parameter is an abstract hash state that is used by the `Hash`
/// to compute the hash.
+///
+/// If you are also implementing `Eq`, there is an additional property that
+/// is important:
+///
+/// ```text
+/// k1 == k2 -> hash(k1) == hash(k2)
+/// ```
+///
+/// In other words, if two keys are equal, their hashes should also be equal.
+/// `HashMap` and `HashSet` both rely on this behavior.
#[stable(feature = "rust1", since = "1.0.0")]
pub trait Hash {
/// Feeds this value into the state given, updating the hasher as necessary.
//! An implementation of SipHash 2-4.
+#![allow(deprecated)] // until the next snapshot for inherent wrapping ops
+
use prelude::*;
use default::Default;
-use num::wrapping::WrappingOps;
use super::Hasher;
/// An implementation of SipHash 2-4.
macro_rules! rotl {
($x:expr, $b:expr) =>
- (($x << $b) | ($x >> (64.wrapping_sub($b))))
+ (($x << $b) | ($x >> (64_i32.wrapping_sub($b))))
}
macro_rules! compress {
use marker::Sized;
-#[cfg(stage0)] pub use self::copy_memory as copy;
-#[cfg(stage0)] pub use self::set_memory as write_bytes;
-#[cfg(stage0)] pub use self::copy_nonoverlapping_memory as copy_nonoverlapping;
-
extern "rust-intrinsic" {
// NB: These intrinsics take unsafe pointers because they mutate aliased
pub fn pref_align_of<T>() -> usize;
/// Gets a static string slice containing the name of a type.
- #[cfg(not(stage0))]
pub fn type_name<T: ?Sized>() -> &'static str;
/// Gets an identifier which is globally unique to the specified type. This
/// crate it is invoked in.
pub fn type_id<T: ?Sized + 'static>() -> u64;
+ /// Create a value initialized to so that its drop flag,
+ /// if any, says that it has been dropped.
+ ///
+ /// `init_dropped` is unsafe because it returns a datum with all
+ /// of its bytes set to the drop flag, which generally does not
+ /// correspond to a valid value.
+ ///
+ /// This intrinsic is likely to be deprecated in the future when
+ /// Rust moves to non-zeroing dynamic drop (and thus removes the
+ /// embedded drop flags that are being established by this
+ /// intrinsic).
+ #[cfg(not(stage0))]
+ pub fn init_dropped<T>() -> T;
+
/// Create a value initialized to zero.
///
/// `init` is unsafe because it returns a zeroed-out datum,
- /// which is unsafe unless T is Copy.
+ /// which is unsafe unless T is `Copy`. Also, even if T is
+ /// `Copy`, an all-zero value may not correspond to any legitimate
+ /// state for the type in question.
pub fn init<T>() -> T;
/// Create an uninitialized value.
+ ///
+ /// `uninit` is unsafe because there is no guarantee of what its
+ /// contents are. In particular its drop-flag may be set to any
+ /// state, which means it may claim either dropped or
+ /// undropped. In the general case one must use `ptr::write` to
+ /// initialize memory previous set to the result of `uninit`.
pub fn uninit<T>() -> T;
/// Move a value out of scope without running drop glue.
/// let mut t: T = mem::uninitialized();
///
/// // Perform the swap, `&mut` pointers never alias
- /// ptr::copy_nonoverlapping(&mut t, &*x, 1);
- /// ptr::copy_nonoverlapping(x, &*y, 1);
- /// ptr::copy_nonoverlapping(y, &t, 1);
+ /// ptr::copy_nonoverlapping(x, &mut t, 1);
+ /// ptr::copy_nonoverlapping(y, x, 1);
+ /// ptr::copy_nonoverlapping(&t, y, 1);
///
/// // y and t now point to the same thing, but we need to completely forget `tmp`
/// // because it's no longer relevant.
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(not(stage0))]
- pub fn copy_nonoverlapping<T>(dst: *mut T, src: *const T, count: usize);
+ pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
/// dox
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(stage0)]
- pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: usize);
+ pub fn copy_nonoverlapping<T>(dst: *mut T, src: *const T, count: usize);
/// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
/// and destination may overlap.
/// # #![feature(core)]
/// use std::ptr;
///
- /// unsafe fn from_buf_raw<T>(ptr: *const T, elts: uint) -> Vec<T> {
+ /// unsafe fn from_buf_raw<T>(ptr: *const T, elts: usize) -> Vec<T> {
/// let mut dst = Vec::with_capacity(elts);
/// dst.set_len(elts);
- /// ptr::copy(dst.as_mut_ptr(), ptr, elts);
+ /// ptr::copy(ptr, dst.as_mut_ptr(), elts);
/// dst
/// }
/// ```
///
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn copy<T>(dst: *mut T, src: *const T, count: usize);
+ #[cfg(not(stage0))]
+ pub fn copy<T>(src: *const T, dst: *mut T, count: usize);
/// dox
- #[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn copy_memory<T>(dst: *mut T, src: *const T, count: usize);
+ #[cfg(stage0)]
+ pub fn copy<T>(dst: *mut T, src: *const T, count: usize);
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`.
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
- /// dox
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn set_memory<T>(dst: *mut T, val: u8, count: usize);
-
/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
/// a size of `count` * `size_of::<T>()` and an alignment of
/// `min_align_of::<T>()`
use default::Default;
use marker;
use mem;
-use num::{ToPrimitive, Int};
-use ops::{Add, FnMut, RangeFrom};
+use num::{Int, Zero, One, ToPrimitive};
+use ops::{Add, Sub, FnMut, RangeFrom};
use option::Option;
use option::Option::{Some, None};
use marker::Sized;
use usize;
+fn _assert_is_object_safe(_: &Iterator) {}
+
/// An interface for dealing with "external iterators". These types of iterators
/// can be resumed at any time as all state is stored internally as opposed to
/// being located on the call stack.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn size_hint(&self) -> (usize, Option<usize>) { (0, None) }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, I: Iterator + ?Sized> Iterator for &'a mut I {
- type Item = I::Item;
- fn next(&mut self) -> Option<I::Item> { (**self).next() }
- fn size_hint(&self) -> (usize, Option<usize>) { (**self).size_hint() }
-}
-
-/// Conversion from an `Iterator`
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_on_unimplemented="a collection of type `{Self}` cannot be \
- built from an iterator over elements of type `{A}`"]
-pub trait FromIterator<A> {
- /// Build a container with elements from something iterable.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn from_iter<T: IntoIterator<Item=A>>(iterator: T) -> Self;
-}
-
-/// Conversion into an `Iterator`
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait IntoIterator {
- /// The type of the elements being iterated
- #[stable(feature = "rust1", since = "1.0.0")]
- type Item;
-
- /// A container for iterating over elements of type Item
- #[stable(feature = "rust1", since = "1.0.0")]
- type IntoIter: Iterator<Item=Self::Item>;
-
- /// Consumes `Self` and returns an iterator over it
- #[stable(feature = "rust1", since = "1.0.0")]
- fn into_iter(self) -> Self::IntoIter;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<I: Iterator> IntoIterator for I {
- type Item = I::Item;
- type IntoIter = I;
-
- fn into_iter(self) -> I {
- self
- }
-}
-/// A type growable from an `Iterator` implementation
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait Extend<A> {
- /// Extend a container with the elements yielded by an arbitrary iterator
- #[stable(feature = "rust1", since = "1.0.0")]
- fn extend<T: IntoIterator<Item=A>>(&mut self, iterable: T);
-}
-
-/// An extension trait providing numerous methods applicable to all iterators.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait IteratorExt: Iterator + Sized {
/// Counts the number of elements in this iterator.
///
/// # Examples
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn count(self) -> usize {
+ fn count(self) -> usize where Self: Sized {
self.fold(0, |cnt, _x| cnt + 1)
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn last(self) -> Option<Self::Item> {
+ fn last(self) -> Option<Self::Item> where Self: Sized {
let mut last = None;
for x in self { last = Some(x); }
last
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
+ fn nth(&mut self, mut n: usize) -> Option<Self::Item> where Self: Sized {
for x in self.by_ref() {
if n == 0 { return Some(x) }
n -= 1;
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn chain<U>(self, other: U) -> Chain<Self, U> where
- U: Iterator<Item=Self::Item>,
+ Self: Sized, U: Iterator<Item=Self::Item>,
{
Chain{a: self, b: other, flag: false}
}
/// assert_eq!(it.next().unwrap(), (&0, &1));
/// assert!(it.next().is_none());
/// ```
+ ///
+ /// `zip` can provide similar functionality to `enumerate`:
+ ///
+ /// ```
+ /// for pair in "foo".chars().enumerate() {
+ /// println!("{:?}", pair);
+ /// }
+ ///
+ /// for pair in (0..).zip("foo".chars()) {
+ /// println!("{:?}", pair);
+ /// }
+ /// ```
+ ///
+ /// both produce the same output.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn zip<U: Iterator>(self, other: U) -> Zip<Self, U> {
+ fn zip<U: Iterator>(self, other: U) -> Zip<Self, U> where Self: Sized {
Zip{a: self, b: other}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn map<B, F>(self, f: F) -> Map<Self, F> where
- F: FnMut(Self::Item) -> B,
+ Self: Sized, F: FnMut(Self::Item) -> B,
{
Map{iter: self, f: f}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
- P: FnMut(&Self::Item) -> bool,
+ Self: Sized, P: FnMut(&Self::Item) -> bool,
{
Filter{iter: self, predicate: predicate}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
- F: FnMut(Self::Item) -> Option<B>,
+ Self: Sized, F: FnMut(Self::Item) -> Option<B>,
{
FilterMap { iter: self, f: f }
}
/// Creates an iterator that yields a pair of the value returned by this
/// iterator plus the current index of iteration.
///
+ /// `enumerate` keeps its count as a `usize`. If you want to count by a
+ /// different sized integer, the `zip` function provides similar functionality.
+ ///
/// # Examples
///
/// ```
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn enumerate(self) -> Enumerate<Self> {
+ fn enumerate(self) -> Enumerate<Self> where Self: Sized {
Enumerate{iter: self, count: 0}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn peekable(self) -> Peekable<Self> {
+ fn peekable(self) -> Peekable<Self> where Self: Sized {
Peekable{iter: self, peeked: None}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
- P: FnMut(&Self::Item) -> bool,
+ Self: Sized, P: FnMut(&Self::Item) -> bool,
{
SkipWhile{iter: self, flag: false, predicate: predicate}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
- P: FnMut(&Self::Item) -> bool,
+ Self: Sized, P: FnMut(&Self::Item) -> bool,
{
TakeWhile{iter: self, flag: false, predicate: predicate}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn skip(self, n: usize) -> Skip<Self> {
+ fn skip(self, n: usize) -> Skip<Self> where Self: Sized {
Skip{iter: self, n: n}
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn take(self, n: usize) -> Take<Self> {
+ fn take(self, n: usize) -> Take<Self> where Self: Sized, {
Take{iter: self, n: n}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
- where F: FnMut(&mut St, Self::Item) -> Option<B>,
+ where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
{
Scan{iter: self, f: f, state: initial_state}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
- where U: Iterator, F: FnMut(Self::Item) -> U,
+ where Self: Sized, U: Iterator, F: FnMut(Self::Item) -> U,
{
FlatMap{iter: self, f: f, frontiter: None, backiter: None }
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn fuse(self) -> Fuse<Self> {
+ fn fuse(self) -> Fuse<Self> where Self: Sized {
Fuse{iter: self, done: false}
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
- F: FnMut(&Self::Item),
+ Self: Sized, F: FnMut(&Self::Item),
{
Inspect{iter: self, f: f}
}
/// assert!(it.next() == Some(5));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- fn by_ref(&mut self) -> &mut Self { self }
+ fn by_ref(&mut self) -> &mut Self where Self: Sized { self }
/// Loops through the entire iterator, collecting all of the elements into
/// a container implementing `FromIterator`.
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn collect<B: FromIterator<Self::Item>>(self) -> B {
+ fn collect<B: FromIterator<Self::Item>>(self) -> B where Self: Sized {
FromIterator::from_iter(self)
}
#[unstable(feature = "core",
reason = "recently added as part of collections reform")]
fn partition<B, F>(self, mut f: F) -> (B, B) where
+ Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool
{
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn fold<B, F>(self, init: B, mut f: F) -> B where
- F: FnMut(B, Self::Item) -> B,
+ Self: Sized, F: FnMut(B, Self::Item) -> B,
{
let mut accum = init;
for x in self {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn all<F>(&mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool {
+ fn all<F>(&mut self, mut f: F) -> bool where
+ Self: Sized, F: FnMut(Self::Item) -> bool
+ {
for x in self.by_ref() { if !f(x) { return false; } }
true
}
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn any<F>(&mut self, mut f: F) -> bool where F: FnMut(Self::Item) -> bool {
+ fn any<F>(&mut self, mut f: F) -> bool where
+ Self: Sized,
+ F: FnMut(Self::Item) -> bool
+ {
for x in self.by_ref() { if f(x) { return true; } }
false
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
+ Self: Sized,
P: FnMut(&Self::Item) -> bool,
{
for x in self.by_ref() {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn position<P>(&mut self, mut predicate: P) -> Option<usize> where
+ Self: Sized,
P: FnMut(Self::Item) -> bool,
{
let mut i = 0;
#[stable(feature = "rust1", since = "1.0.0")]
fn rposition<P>(&mut self, mut predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
- Self: ExactSizeIterator + DoubleEndedIterator
+ Self: Sized + ExactSizeIterator + DoubleEndedIterator
{
let mut i = self.len();
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn max(self) -> Option<Self::Item> where Self::Item: Ord
+ fn max(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord
{
self.fold(None, |max, x| {
match max {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn min(self) -> Option<Self::Item> where Self::Item: Ord
+ fn min(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord
{
self.fold(None, |min, x| {
match min {
/// assert!(a.iter().min_max() == MinMax(&1, &1));
/// ```
#[unstable(feature = "core", reason = "return type may change")]
- fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord
+ fn min_max(mut self) -> MinMaxResult<Self::Item> where Self: Sized, Self::Item: Ord
{
let (mut min, mut max) = match self.next() {
None => return NoElements,
///
/// ```
/// # #![feature(core)]
- /// use std::num::SignedInt;
///
- /// let a = [-3, 0, 1, 5, -10];
+ /// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().max_by(|x| x.abs()).unwrap(), -10);
/// ```
#[inline]
#[unstable(feature = "core",
reason = "may want to produce an Ordering directly; see #15311")]
fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
+ Self: Sized,
F: FnMut(&Self::Item) -> B,
{
self.fold(None, |max: Option<(Self::Item, B)>, x| {
///
/// ```
/// # #![feature(core)]
- /// use std::num::SignedInt;
///
- /// let a = [-3, 0, 1, 5, -10];
+ /// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().min_by(|x| x.abs()).unwrap(), 0);
/// ```
#[inline]
#[unstable(feature = "core",
reason = "may want to produce an Ordering directly; see #15311")]
fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
+ Self: Sized,
F: FnMut(&Self::Item) -> B,
{
self.fold(None, |min: Option<(Self::Item, B)>, x| {
/// `std::usize::MAX` elements of the original iterator.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- fn rev(self) -> Rev<Self> {
+ fn rev(self) -> Rev<Self> where Self: Sized {
Rev{iter: self}
}
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
- Self: Iterator<Item=(A, B)>,
+ Self: Sized + Iterator<Item=(A, B)>,
{
struct SizeHint<A>(usize, Option<usize>, marker::PhantomData<A>);
impl<A> Iterator for SizeHint<A> {
/// converting an Iterator<&T> to an Iterator<T>.
#[stable(feature = "rust1", since = "1.0.0")]
fn cloned<'a, T: 'a>(self) -> Cloned<Self>
- where Self: Iterator<Item=&'a T>, T: Clone
+ where Self: Sized + Iterator<Item=&'a T>, T: Clone
{
Cloned { it: self }
}
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- fn cycle(self) -> Cycle<Self> where Self: Clone {
+ fn cycle(self) -> Cycle<Self> where Self: Sized + Clone {
Cycle{orig: self.clone(), iter: self}
}
#[unstable(feature = "core",
reason = "uncertain about placement or widespread use")]
fn reverse_in_place<'a, T: 'a>(&mut self) where
- Self: Iterator<Item=&'a mut T> + DoubleEndedIterator
+ Self: Sized + Iterator<Item=&'a mut T> + DoubleEndedIterator
{
loop {
match (self.next(), self.next_back()) {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<I> IteratorExt for I where I: Iterator {}
+impl<'a, I: Iterator + ?Sized> Iterator for &'a mut I {
+ type Item = I::Item;
+ fn next(&mut self) -> Option<I::Item> { (**self).next() }
+ fn size_hint(&self) -> (usize, Option<usize>) { (**self).size_hint() }
+}
+
+/// Conversion from an `Iterator`
+#[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_on_unimplemented="a collection of type `{Self}` cannot be \
+ built from an iterator over elements of type `{A}`"]
+pub trait FromIterator<A> {
+ /// Build a container with elements from something iterable.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::collections::HashSet;
+ /// use std::iter::FromIterator;
+ ///
+ /// let colors_vec = vec!["red", "red", "yellow", "blue"];
+ /// let colors_set = HashSet::<&str>::from_iter(colors_vec);
+ /// assert_eq!(colors_set.len(), 3);
+ /// ```
+ ///
+ /// `FromIterator` is more commonly used implicitly via the `Iterator::collect` method:
+ ///
+ /// ```
+ /// use std::collections::HashSet;
+ ///
+ /// let colors_vec = vec!["red", "red", "yellow", "blue"];
+ /// let colors_set = colors_vec.into_iter().collect::<HashSet<&str>>();
+ /// assert_eq!(colors_set.len(), 3);
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn from_iter<T: IntoIterator<Item=A>>(iterator: T) -> Self;
+}
+
+/// Conversion into an `Iterator`
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait IntoIterator {
+ /// The type of the elements being iterated
+ #[stable(feature = "rust1", since = "1.0.0")]
+ type Item;
+
+ /// A container for iterating over elements of type Item
+ #[stable(feature = "rust1", since = "1.0.0")]
+ type IntoIter: Iterator<Item=Self::Item>;
+
+ /// Consumes `Self` and returns an iterator over it
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn into_iter(self) -> Self::IntoIter;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<I: Iterator> IntoIterator for I {
+ type Item = I::Item;
+ type IntoIter = I;
+
+ fn into_iter(self) -> I {
+ self
+ }
+}
+
+/// A type growable from an `Iterator` implementation
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait Extend<A> {
+ /// Extend a container with the elements yielded by an arbitrary iterator
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn extend<T: IntoIterator<Item=A>>(&mut self, iterable: T);
+}
/// A range iterator able to yield elements from both ends
///
impl_multiplicative! { f32, 1.0 }
impl_multiplicative! { f64, 1.0 }
-/// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail.
+/// `MinMaxResult` is an enum returned by `min_max`. See `Iterator::min_max` for more detail.
#[derive(Clone, PartialEq, Debug)]
#[unstable(feature = "core",
reason = "unclear whether such a fine-grained result is widely useful")]
}
}
+/// Objects that can be stepped over in both directions.
+///
+/// The `steps_between` function provides a way to efficiently compare
+/// two `Step` objects.
+#[unstable(feature = "step_trait",
+ reason = "likely to be replaced by finer-grained traits")]
+pub trait Step: Ord {
+ /// Steps `self` if possible.
+ fn step(&self, by: &Self) -> Option<Self>;
+
+ /// The number of steps between two step objects.
+ ///
+ /// `start` should always be less than `end`, so the result should never
+ /// be negative.
+ ///
+ /// Return `None` if it is not possible to calculate steps_between
+ /// without overflow.
+ fn steps_between(start: &Self, end: &Self, by: &Self) -> Option<usize>;
+}
+
+macro_rules! step_impl {
+ ($($t:ty)*) => ($(
+ impl Step for $t {
+ #[inline]
+ fn step(&self, by: &$t) -> Option<$t> {
+ (*self).checked_add(*by)
+ }
+ #[inline]
+ #[allow(trivial_numeric_casts)]
+ fn steps_between(start: &$t, end: &$t, by: &$t) -> Option<usize> {
+ if *start <= *end {
+ Some(((*end - *start) / *by) as usize)
+ } else {
+ Some(0)
+ }
+ }
+ }
+ )*)
+}
+
+macro_rules! step_impl_no_between {
+ ($($t:ty)*) => ($(
+ impl Step for $t {
+ #[inline]
+ fn step(&self, by: &$t) -> Option<$t> {
+ (*self).checked_add(*by)
+ }
+ #[inline]
+ fn steps_between(_a: &$t, _b: &$t, _by: &$t) -> Option<usize> {
+ None
+ }
+ }
+ )*)
+}
+
+step_impl!(usize u8 u16 u32 isize i8 i16 i32);
+#[cfg(target_pointer_width = "64")]
+step_impl!(u64 i64);
+#[cfg(target_pointer_width = "32")]
+step_impl_no_between!(u64 i64);
+
/// An adapter for stepping range iterators by a custom amount.
///
/// The resulting iterator handles overflow by stopping. The `A`
range: R,
}
-impl<A:
Add> RangeFrom<A> {
+impl<A:
Step> RangeFrom<A> {
/// Creates an iterator starting at the same point, but stepping by
/// the given amount at each iteration.
///
}
}
-impl<A: Int> ::ops::Range<A> {
+#[allow(deprecated)]
+impl<A: Step> ::ops::Range<A> {
/// Creates an iterator with the same range, but stepping by the
/// given amount at each iteration.
///
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Add<Output=A> + Clone> Iterator for StepBy<A, RangeFrom<A>> {
+impl<A> Iterator for StepBy<A, RangeFrom<A>> where
+ A: Clone,
+ for<'a> &'a A: Add<&'a A, Output = A>
+{
type Item = A;
#[inline]
fn next(&mut self) -> Option<A> {
- let result = self.range.start.clone();
- self.range.start = result.clone() + self.step_by.clone();
- Some(result)
+ let mut n = &self.range.start + &self.step_by;
+ mem::swap(&mut n, &mut self.range.start);
+ Some(n)
}
#[inline]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Int> Iterator for StepBy<A, ::ops::Range<A>> {
+#[allow(deprecated)]
+impl<A: Step + Zero + Clone> Iterator for StepBy<A, ::ops::Range<A>> {
type Item = A;
#[inline]
fn next(&mut self) -> Option<A> {
- let rev = self.step_by < Int::zero();
- let start = self.range.start;
- if (rev && start > self.range.end) || (!rev && start < self.range.end) {
- match start.checked_add(self.step_by) {
- Some(x) => self.range.start = x,
- None => self.range.start = self.range.end.clone()
+ let rev = self.step_by < A::zero();
+ if (rev && self.range.start > self.range.end) ||
+ (!rev && self.range.start < self.range.end)
+ {
+ match self.range.start.step(&self.step_by) {
+ Some(mut n) => {
+ mem::swap(&mut self.range.start, &mut n);
+ Some(n)
+ },
+ None => {
+ let mut n = self.range.end.clone();
+ mem::swap(&mut self.range.start, &mut n);
+ Some(n)
+ }
}
- Some(start)
} else {
None
}
#[inline]
#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
+#[allow(deprecated)]
pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> {
let rev = step < Int::zero();
RangeStepInclusive {
#[unstable(feature = "core",
reason = "likely to be replaced by range notation and adapters")]
+#[allow(deprecated)]
impl<A: Int> Iterator for RangeStepInclusive<A> {
type Item = A;
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Int> Iterator for ::ops::Range<A> {
+#[allow(deprecated)]
+impl<A: Step + One + Clone> Iterator for ::ops::Range<A> {
type Item = A;
#[inline]
fn next(&mut self) -> Option<A> {
if self.start < self.end {
- let result = self.start;
- self.start = self.start + Int::one();
- Some(result)
+ match self.start.step(&A::one()) {
+ Some(mut n) => {
+ mem::swap(&mut n, &mut self.start);
+ Some(n)
+ },
+ None => {
+ let mut n = self.end.clone();
+ mem::swap(&mut n, &mut self.start);
+ Some(n)
+
+ }
+ }
} else {
None
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
- if self.start >= self.end {
- (0, Some(0))
+ if let Some(hint) = Step::steps_between(&self.start, &self.end, &A::one()) {
+ (hint, Some(hint))
} else {
- let length = (self.end - self.start).to_usize();
- (length.unwrap_or(0), length)
+ (0, None)
}
}
}
range_exact_iter_impl!(usize u8 u16 u32 isize i8 i16 i32);
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Int> DoubleEndedIterator for ::ops::Range<A> {
+#[allow(deprecated)]
+impl<A: Step + One + Clone> DoubleEndedIterator for ::ops::Range<A> where
+ for<'a> &'a A: Sub<&'a A, Output = A>
+{
#[inline]
fn next_back(&mut self) -> Option<A> {
if self.start < self.end {
- self.end = self.end - Int::one();
- Some(self.end)
+ self.end = &self.end - &A::one();
+ Some(self.end.clone())
} else {
None
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Int> Iterator for ::ops::RangeFrom<A> {
+#[allow(deprecated)]
+impl<A: Step + One> Iterator for ::ops::RangeFrom<A> {
type Item = A;
#[inline]
fn next(&mut self) -> Option<A> {
- let result = self.start;
- self.start = self.start + Int::one();
- debug_assert!(result < self.start);
- Some(result)
+ self.start.step(&A::one()).map(|mut n| {
+ mem::swap(&mut n, &mut self.start);
+ n
+ })
}
}
#![allow(raw_pointer_derive)]
#![deny(missing_docs)]
-#![feature(int_uint)]
#![feature(intrinsics, lang_items)]
#![feature(on_unimplemented)]
#![feature(simd, unsafe_destructor)]
#![feature(rustc_attrs)]
#![feature(optin_builtin_traits)]
#![feature(concat_idents)]
+#![feature(reflect)]
#[macro_use]
mod macros;
/// Match arms:
///
/// ```
-/// fn foo(x: Option<int>) {
+/// fn foo(x: Option<i32>) {
/// match x {
/// Some(n) if n >= 0 => println!("Some(Non-negative)"),
/// Some(n) if n < 0 => println!("Some(Negative)"),
#[deprecated(since = "1.0.0", reason = "Replace with `PhantomData<Cell<T>>`")]
#[lang="invariant_type"]
pub struct InvariantType<T>;
+
+/// A marker trait indicates a type that can be reflected over. This
+/// trait is implemented for all types. Its purpose is to ensure that
+/// when you write a generic function that will employ reflection,
+/// that must be reflected (no pun intended) in the generic bounds of
+/// that function. Here is an example:
+///
+/// ```
+/// #![feature(core)]
+/// use std::marker::Reflect;
+/// use std::any::Any;
+/// fn foo<T:Reflect+'static>(x: &T) {
+/// let any: &Any = x;
+/// if any.is::<u32>() { println!("u32"); }
+/// }
+/// ```
+///
+/// Without the declaration `T:Reflect`, `foo` would not type check
+/// (note: as a matter of style, it would be preferable to to write
+/// `T:Any`, because `T:Any` implies `T:Reflect` and `T:'static`, but
+/// we use `Reflect` here to show how it works). The `Reflect` bound
+/// thus serves to alert `foo`'s caller to the fact that `foo` may
+/// behave differently depending on whether `T=u32` or not. In
+/// particular, thanks to the `Reflect` bound, callers know that a
+/// function declared like `fn bar<T>(...)` will always act in
+/// precisely the same way no matter what type `T` is supplied,
+/// because there are no bounds declared on `T`. (The ability for a
+/// caller to reason about what a function may do based solely on what
+/// generic bounds are declared is often called the ["parametricity
+/// property"][1].)
+///
+/// [1]: http://en.wikipedia.org/wiki/Parametricity
+#[rustc_reflect_like]
+#[unstable(feature = "core", reason = "requires RFC and more experience")]
+pub trait Reflect : MarkerTrait {
+}
+
+#[cfg(stage0)]
+impl<T> Reflect for T { }
+
+#[cfg(not(stage0))]
+impl Reflect for .. { }
+
intrinsics::init()
}
+/// Create a value initialized to an unspecified series of bytes.
+///
+/// The byte sequence usually indicates that the value at the memory
+/// in question has been dropped. Thus, *if* T carries a drop flag,
+/// any associated destructor will not be run when the value falls out
+/// of scope.
+///
+/// Some code at one time used the `zeroed` function above to
+/// accomplish this goal.
+///
+/// This function is expected to be deprecated with the transition
+/// to non-zeroing drop.
+#[inline]
+#[unstable(feature = "filling_drop")]
+pub unsafe fn dropped<T>() -> T {
+ #[cfg(stage0)]
+ #[inline(always)]
+ unsafe fn dropped_impl<T>() -> T { zeroed() }
+
+ #[cfg(not(stage0))]
+ #[inline(always)]
+ unsafe fn dropped_impl<T>() -> T { intrinsics::init_dropped() }
+
+ dropped_impl()
+}
+
/// Create an uninitialized value.
///
/// Care must be taken when using this function, if the type `T` has a destructor and the value
let mut t: T = uninitialized();
// Perform the swap, `&mut` pointers never alias
- ptr::copy_nonoverlapping(&mut t, &*x, 1);
- ptr::copy_nonoverlapping(x, &*y, 1);
- ptr::copy_nonoverlapping(y, &t, 1);
+ ptr::copy_nonoverlapping(&*x, &mut t, 1);
+ ptr::copy_nonoverlapping(&*y, x, 1);
+ ptr::copy_nonoverlapping(&t, y, 1);
// y and t now point to the same thing, but we need to completely forget `t`
// because it's no longer relevant.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn drop<T>(_x: T) { }
+macro_rules! repeat_u8_as_u32 {
+ ($name:expr) => { (($name as u32) << 24 |
+ ($name as u32) << 16 |
+ ($name as u32) << 8 |
+ ($name as u32)) }
+}
+macro_rules! repeat_u8_as_u64 {
+ ($name:expr) => { ((repeat_u8_as_u32!($name) as u64) << 32 |
+ (repeat_u8_as_u32!($name) as u64)) }
+}
+
+// NOTE: Keep synchronized with values used in librustc_trans::trans::adt.
+//
+// In particular, the POST_DROP_U8 marker must never equal the
+// DTOR_NEEDED_U8 marker.
+//
+// For a while pnkfelix was using 0xc1 here.
+// But having the sign bit set is a pain, so 0x1d is probably better.
+//
+// And of course, 0x00 brings back the old world of zero'ing on drop.
+#[cfg(not(stage0))] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_U8: u8 = 0x1d;
+#[cfg(not(stage0))] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_U32: u32 = repeat_u8_as_u32!(POST_DROP_U8);
+#[cfg(not(stage0))] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_U64: u64 = repeat_u8_as_u64!(POST_DROP_U8);
+
+#[cfg(target_pointer_width = "32")]
+#[cfg(not(stage0))] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_USIZE: usize = POST_DROP_U32 as usize;
+#[cfg(target_pointer_width = "64")]
+#[cfg(not(stage0))] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_USIZE: usize = POST_DROP_U64 as usize;
+
+#[cfg(stage0)] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_U8: u8 = 0;
+#[cfg(stage0)] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_U32: u32 = 0;
+#[cfg(stage0)] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_U64: u64 = 0;
+#[cfg(stage0)] #[unstable(feature = "filling_drop")]
+pub const POST_DROP_USIZE: usize = 0;
+
/// Interprets `src` as `&U`, and then reads `src` without moving the contained value.
///
/// This function will unsafely assume the pointer `src` is valid for `sizeof(U)` bytes by
use num::FpCategory as Fp;
use option::Option;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const RADIX: u32 = 2;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MANTISSA_DIGITS: u32 = 24;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const DIGITS: u32 = 6;
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX: f32 = 3.40282347e+38_f32;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN_EXP: i32 = -125;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX_EXP: i32 = 128;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN_10_EXP: i32 = -37;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX_10_EXP: i32 = 38;
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
-/// Various useful constants.
-#[unstable(feature = "core",
- reason = "naming scheme needs to be revisited")]
+/// Basic mathematial constants.
+#[stable(feature = "rust1", since = "1.0.0")]
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
/// Archimedes' constant
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const PI: f32 = 3.14159265358979323846264338327950288_f32;
/// pi * 2.0
+ #[unstable(feature = "core", reason = "unclear naming convention/usefulness")]
pub const PI_2: f32 = 6.28318530717958647692528676655900576_f32;
/// pi/2.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_2: f32 = 1.57079632679489661923132169163975144_f32;
/// pi/3.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_3: f32 = 1.04719755119659774615421446109316763_f32;
/// pi/4.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_4: f32 = 0.785398163397448309615660845819875721_f32;
/// pi/6.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_6: f32 = 0.52359877559829887307710723054658381_f32;
/// pi/8.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_8: f32 = 0.39269908169872415480783042290993786_f32;
/// 1.0/pi
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_1_PI: f32 = 0.318309886183790671537767526745028724_f32;
/// 2.0/pi
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_2_PI: f32 = 0.636619772367581343075535053490057448_f32;
/// 2.0/sqrt(pi)
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub const FRAC_2_SQRT_PI: f32 = 1.12837916709551257389615890312154517_f32;
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to FRAC_2_SQRT_PI")]
pub const FRAC_2_SQRTPI: f32 = 1.12837916709551257389615890312154517_f32;
/// sqrt(2.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub const SQRT_2: f32 = 1.41421356237309504880168872420969808_f32;
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to SQRT_2")]
pub const SQRT2: f32 = 1.41421356237309504880168872420969808_f32;
/// 1.0/sqrt(2.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub const FRAC_1_SQRT_2: f32 = 0.707106781186547524400844362104849039_f32;
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to FRAC_1_SQRT_2")]
pub const FRAC_1_SQRT2: f32 = 0.707106781186547524400844362104849039_f32;
/// Euler's number
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const E: f32 = 2.71828182845904523536028747135266250_f32;
/// log2(e)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LOG2_E: f32 = 1.44269504088896340735992468100189214_f32;
/// log10(e)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LOG10_E: f32 = 0.434294481903251827651128918916605082_f32;
/// ln(2.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LN_2: f32 = 0.693147180559945309417232121458176568_f32;
/// ln(10.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
}
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn mantissa_digits(_: Option<f32>) -> uint { MANTISSA_DIGITS as uint }
+ fn mantissa_digits(_: Option<f32>) -> usize { MANTISSA_DIGITS as usize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn digits(_: Option<f32>) -> uint { DIGITS as uint }
+ fn digits(_: Option<f32>) -> usize { DIGITS as usize }
#[inline]
#[unstable(feature = "core")]
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn min_exp(_: Option<f32>) -> int { MIN_EXP as int }
+ fn min_exp(_: Option<f32>) -> isize { MIN_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn max_exp(_: Option<f32>) -> int { MAX_EXP as int }
+ fn max_exp(_: Option<f32>) -> isize { MAX_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn min_10_exp(_: Option<f32>) -> int { MIN_10_EXP as int }
+ fn min_10_exp(_: Option<f32>) -> isize { MIN_10_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn max_10_exp(_: Option<f32>) -> int { MAX_10_EXP as int }
+ fn max_10_exp(_: Option<f32>) -> isize { MAX_10_EXP as isize }
#[inline]
#[unstable(feature = "core")]
use num::FpCategory as Fp;
use option::Option;
-// FIXME(#5527): These constants should be deprecated once associated
-// constants are implemented in favour of referencing the respective
-// members of `Bounded` and `Float`.
-
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const RADIX: u32 = 2;
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MANTISSA_DIGITS: u32 = 53;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const DIGITS: u32 = 15;
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX: f64 = 1.7976931348623157e+308_f64;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN_EXP: i32 = -1021;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX_EXP: i32 = 1024;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN_10_EXP: i32 = -307;
-#[unstable(feature = "core", reason = "pending integer conventions")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX_10_EXP: i32 = 308;
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
-/// Various useful constants.
-#[unstable(feature = "core",
- reason = "naming scheme needs to be revisited")]
+/// Basic mathematial constants.
+#[stable(feature = "rust1", since = "1.0.0")]
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
- // FIXME(#5527): These constants should be deprecated once associated
- // constants are implemented in favour of referencing the respective members
- // of `Float`.
-
/// Archimedes' constant
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const PI: f64 = 3.14159265358979323846264338327950288_f64;
/// pi * 2.0
+ #[unstable(feature = "core", reason = "unclear naming convention/usefulness")]
pub const PI_2: f64 = 6.28318530717958647692528676655900576_f64;
/// pi/2.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64;
/// pi/3.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64;
/// pi/4.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64;
/// pi/6.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64;
/// pi/8.0
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64;
/// 1.0/pi
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64;
/// 2.0/pi
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64;
/// 2.0/sqrt(pi)
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64;
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to FRAC_2_SQRT_PI")]
pub const FRAC_2_SQRTPI: f64 = 1.12837916709551257389615890312154517_f64;
/// sqrt(2.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64;
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to SQRT_2")]
pub const SQRT2: f64 = 1.41421356237309504880168872420969808_f64;
/// 1.0/sqrt(2.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to FRAC_1_SQRT_2")]
pub const FRAC_1_SQRT2: f64 = 0.707106781186547524400844362104849039_f64;
/// Euler's number
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const E: f64 = 2.71828182845904523536028747135266250_f64;
/// log2(e)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64;
/// log10(e)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64;
/// ln(2.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64;
/// ln(10.0)
+ #[stable(feature = "rust1", since = "1.0.0")]
pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
}
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn mantissa_digits(_: Option<f64>) -> uint { MANTISSA_DIGITS as uint }
+ fn mantissa_digits(_: Option<f64>) -> usize { MANTISSA_DIGITS as usize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn digits(_: Option<f64>) -> uint { DIGITS as uint }
+ fn digits(_: Option<f64>) -> usize { DIGITS as usize }
#[inline]
#[unstable(feature = "core")]
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn min_exp(_: Option<f64>) -> int { MIN_EXP as int }
+ fn min_exp(_: Option<f64>) -> isize { MIN_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn max_exp(_: Option<f64>) -> int { MAX_EXP as int }
+ fn max_exp(_: Option<f64>) -> isize { MAX_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn min_10_exp(_: Option<f64>) -> int { MIN_10_EXP as int }
+ fn min_10_exp(_: Option<f64>) -> isize { MIN_10_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0")]
- fn max_10_exp(_: Option<f64>) -> int { MAX_10_EXP as int }
+ fn max_10_exp(_: Option<f64>) -> isize { MAX_10_EXP as isize }
#[inline]
#[unstable(feature = "core")]
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "i16")]
-#![allow(trivial_numeric_casts)]
int_module! { i16, 16 }
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "i32")]
-#![allow(trivial_numeric_casts)]
int_module! { i32, 32 }
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "i64")]
-#![allow(trivial_numeric_casts)]
int_module! { i64, 64 }
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "i8")]
-#![allow(trivial_numeric_casts)]
int_module! { i8, 8 }
// except according to those terms.
#![doc(hidden)]
-#![allow(trivial_numeric_casts)]
macro_rules! int_module { ($T:ty, $bits:expr) => (
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "isize")]
-#![allow(trivial_numeric_casts)]
#[cfg(target_pointer_width = "32")]
int_module! { isize, 32 }
#![stable(feature = "rust1", since = "1.0.0")]
#![allow(missing_docs)]
-#![allow(trivial_numeric_casts)]
use self::wrapping::{OverflowingOps, WrappingOps};
use error::Error;
use fmt;
use intrinsics;
-use iter::IteratorExt;
+use iter::Iterator;
use marker::Copy;
use mem::size_of;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
use result::Result::{self, Ok, Err};
use str::{FromStr, StrExt};
+/// Provides intentionally-wrapped arithmetic on `T`.
+///
+/// Operations like `+` on `u32` values is intended to never overflow,
+/// and in some debug configurations overflow is detected and results
+/// in a panic. While most arithmetic falls into this category, some
+/// code explicitly expects and relies upon modular arithmetic (e.g.,
+/// hashing).
+///
+/// Wrapping arithmetic can be achieved either through methods like
+/// `wrapping_add`, or through the `Wrapping<T>` type, which says that
+/// all standard arithmetic operations on the underlying value are
+/// intended to have wrapping semantics.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
+pub struct Wrapping<T>(pub T);
+
#[unstable(feature = "core", reason = "may be removed or relocated")]
pub mod wrapping;
+/// Types that have a "zero" value.
+///
+/// This trait is intended for use in conjunction with `Add`, as an identity:
+/// `x + T::zero() == x`.
+#[unstable(feature = "zero_one",
+ reason = "unsure of placement, wants to use associated constants")]
+pub trait Zero {
+ /// The "zero" (usually, additive identity) for this type.
+ fn zero() -> Self;
+}
+
+/// Types that have a "one" value.
+///
+/// This trait is intended for use in conjunction with `Mul`, as an identity:
+/// `x * T::one() == x`.
+#[unstable(feature = "zero_one",
+ reason = "unsure of placement, wants to use associated constants")]
+pub trait One {
+ /// The "one" (usually, multiplicative identity) for this type.
+ fn one() -> Self;
+}
+
+macro_rules! zero_one_impl {
+ ($($t:ty)*) => ($(
+ impl Zero for $t {
+ #[inline]
+ fn zero() -> $t { 0 }
+ }
+ impl One for $t {
+ #[inline]
+ fn one() -> $t { 1 }
+ }
+ )*)
+}
+zero_one_impl! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
+
/// A built-in signed or unsigned integer.
#[stable(feature = "rust1", since = "1.0.0")]
+#[deprecated(since = "1.0.0",
+ reason = "replaced by inherent methods; for generics, use rust-lang/num")]
+#[allow(deprecated)]
pub trait Int
: Copy + Clone
+ NumCast
+ BitAnd<Output=Self>
+ BitOr<Output=Self>
+ BitXor<Output=Self>
- + Shl<uint, Output=Self>
- + Shr<uint, Output=Self>
+ + Shl<usize, Output=Self>
+ + Shr<usize, Output=Self>
+ WrappingOps
+ OverflowingOps
{
$sub_with_overflow:path,
$mul_with_overflow:path) => {
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
impl Int for $T {
#[inline]
fn zero() -> $T { 0 }
intrinsics::u64_mul_with_overflow }
#[cfg(target_pointer_width = "32")]
-uint_impl! { uint = u32, 32,
+uint_impl! { usize = u32, 32,
intrinsics::ctpop32,
intrinsics::ctlz32,
intrinsics::cttz32,
intrinsics::u32_mul_with_overflow }
#[cfg(target_pointer_width = "64")]
-uint_impl! { uint = u64, 64,
+uint_impl! { usize = u64, 64,
intrinsics::ctpop64,
intrinsics::ctlz64,
intrinsics::cttz64,
$sub_with_overflow:path,
$mul_with_overflow:path) => {
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
impl Int for $T {
#[inline]
fn zero() -> $T { 0 }
intrinsics::i64_mul_with_overflow }
#[cfg(target_pointer_width = "32")]
-int_impl! { int = i32, u32, 32,
+int_impl! { isize = i32, u32, 32,
intrinsics::i32_add_with_overflow,
intrinsics::i32_sub_with_overflow,
intrinsics::i32_mul_with_overflow }
#[cfg(target_pointer_width = "64")]
-int_impl! { int = i64, u64, 64,
+int_impl! { isize = i64, u64, 64,
intrinsics::i64_add_with_overflow,
intrinsics::i64_sub_with_overflow,
intrinsics::i64_mul_with_overflow }
/// A built-in two's complement integer.
#[stable(feature = "rust1", since = "1.0.0")]
+#[deprecated(since = "1.0.0",
+ reason = "replaced by inherent methods; for generics, use rust-lang/num")]
+#[allow(deprecated)]
pub trait SignedInt
: Int
+ Neg<Output=Self>
macro_rules! signed_int_impl {
($T:ty) => {
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
impl SignedInt for $T {
#[inline]
fn abs(self) -> $T {
signed_int_impl! { i16 }
signed_int_impl! { i32 }
signed_int_impl! { i64 }
-signed_int_impl! { int }
+signed_int_impl! { isize }
// `Int` + `SignedInt` implemented for signed integers
macro_rules! int_impl {
$add_with_overflow:path,
$sub_with_overflow:path,
$mul_with_overflow:path) => {
- /// Returns the `0` value of this integer type.
- // FIXME (#5527): Should be an associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn zero() -> $T { 0 }
-
- /// Returns the `1` value of this integer type.
- // FIXME (#5527): Should be an associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn one() -> $T { 1 }
-
- /// Returns the smallest value that can be represented by this integer
- /// type.
- // FIXME (#5527): Should be and associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn min_value() -> $T { (-1 as $T) << ($BITS - 1) }
-
- /// Returns the largest value that can be represented by this integer
- /// type.
- // FIXME (#5527): Should be and associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn max_value() -> $T { let min: $T = <$T>::min_value(); !min }
+ /// Convert a string slice in a given base to an integer.
+ ///
+ /// Leading and trailing whitespace represent an error.
+ ///
+ /// # Arguments
+ ///
+ /// * src - A string slice
+ /// * radix - The base to use. Must lie in the range [2 .. 36]
+ ///
+ /// # Return value
+ ///
+ /// `None` if the string did not represent a valid number.
+ /// Otherwise, `Some(n)` where `n` is the integer represented
+ /// by `src`.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
+ pub fn from_str_radix(src: &str, radix: u32) -> Result<$T, ParseIntError> {
+ <Self as FromStrRadix>::from_str_radix(src, radix)
+ }
/// Returns the number of ones in the binary representation of `self`.
///
///
/// assert_eq!(n.count_ones(), 3);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }
///
/// assert_eq!(n.count_zeros(), 5);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn count_zeros(self) -> u32 {
(!self).count_ones()
///
/// assert_eq!(n.leading_zeros(), 10);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn leading_zeros(self) -> u32 {
(self as $UnsignedT).leading_zeros()
///
/// assert_eq!(n.trailing_zeros(), 3);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn trailing_zeros(self) -> u32 {
(self as $UnsignedT).trailing_zeros()
///
/// assert_eq!(n.rotate_left(12), m);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn rotate_left(self, n: u32) -> $T {
(self as $UnsignedT).rotate_left(n) as $T
///
/// assert_eq!(n.rotate_right(12), m);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn rotate_right(self, n: u32) -> $T {
(self as $UnsignedT).rotate_right(n) as $T
pub fn saturating_add(self, other: $T) -> $T {
match self.checked_add(other) {
Some(x) => x,
- None if other >= <$T>::zero() => <$T>::max_value(),
- None => <$T>::min_value(),
+ None if other >= <$T as Zero>::zero() => <$T>::max_value(),
+ None => <$T>::min_value(),
}
}
pub fn saturating_sub(self, other: $T) -> $T {
match self.checked_sub(other) {
Some(x) => x,
- None if other >= <$T>::zero() => <$T>::min_value(),
- None => <$T>::max_value(),
+ None if other >= <$T as Zero>::zero() => <$T>::min_value(),
+ None => <$T>::max_value(),
+ }
+ }
+
+ /// Wrapping (modular) addition. Computes `self + other`,
+ /// wrapping around at the boundary of the type.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_add(self, rhs: $T) -> $T {
+ unsafe {
+ intrinsics::overflowing_add(self, rhs)
+ }
+ }
+
+ /// Wrapping (modular) subtraction. Computes `self - other`,
+ /// wrapping around at the boundary of the type.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_sub(self, rhs: $T) -> $T {
+ unsafe {
+ intrinsics::overflowing_sub(self, rhs)
+ }
+ }
+
+ /// Wrapping (modular) multiplication. Computes `self *
+ /// other`, wrapping around at the boundary of the type.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_mul(self, rhs: $T) -> $T {
+ unsafe {
+ intrinsics::overflowing_mul(self, rhs)
}
}
///
/// assert_eq!(2.pow(4), 16);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn pow(self, mut exp: u32) -> $T {
let mut base = self;
- let mut acc = <$T>::one();
+ let mut acc = <$T as One>::one();
let mut prev_base = self;
let mut base_oflo = false;
/// Computes the absolute value of `self`. `Int::min_value()` will be
/// returned if the number is `Int::min_value()`.
- #[unstable(feature = "core", reason = "overflow in debug builds?")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn abs(self) -> $T {
if self.is_negative() { -self } else { self }
#[cfg(target_pointer_width = "32")]
#[lang = "isize"]
impl isize {
- int_impl! { int = i32, u32, 32,
+ int_impl! { isize = i32, u32, 32,
intrinsics::i32_add_with_overflow,
intrinsics::i32_sub_with_overflow,
intrinsics::i32_mul_with_overflow }
#[cfg(target_pointer_width = "64")]
#[lang = "isize"]
impl isize {
- int_impl! { int = i64, u64, 64,
+ int_impl! { isize = i64, u64, 64,
intrinsics::i64_add_with_overflow,
intrinsics::i64_sub_with_overflow,
intrinsics::i64_mul_with_overflow }
$add_with_overflow:path,
$sub_with_overflow:path,
$mul_with_overflow:path) => {
- /// Returns the `0` value of this integer type.
- // FIXME (#5527): Should be an associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn zero() -> $T { 0 }
-
- /// Returns the `1` value of this integer type.
- // FIXME (#5527): Should be an associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn one() -> $T { 1 }
-
- /// Returns the smallest value that can be represented by this integer
- /// type.
- // FIXME (#5527): Should be and associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn min_value() -> $T { 0 }
-
- /// Returns the largest value that can be represented by this integer
- /// type.
- // FIXME (#5527): Should be and associated constant
- #[unstable(feature = "core",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn max_value() -> $T { -1 }
+ /// Convert a string slice in a given base to an integer.
+ ///
+ /// Leading and trailing whitespace represent an error.
+ ///
+ /// # Arguments
+ ///
+ /// * src - A string slice
+ /// * radix - The base to use. Must lie in the range [2 .. 36]
+ ///
+ /// # Return value
+ ///
+ /// `None` if the string did not represent a valid number.
+ /// Otherwise, `Some(n)` where `n` is the integer represented
+ /// by `src`.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
+ pub fn from_str_radix(src: &str, radix: u32) -> Result<$T, ParseIntError> {
+ <Self as FromStrRadix>::from_str_radix(src, radix)
+ }
/// Returns the number of ones in the binary representation of `self`.
///
///
/// assert_eq!(n.count_ones(), 3);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn count_ones(self) -> u32 {
unsafe { $ctpop(self as $ActualT) as u32 }
///
/// assert_eq!(n.count_zeros(), 5);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn count_zeros(self) -> u32 {
(!self).count_ones()
///
/// assert_eq!(n.leading_zeros(), 10);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn leading_zeros(self) -> u32 {
unsafe { $ctlz(self as $ActualT) as u32 }
///
/// assert_eq!(n.trailing_zeros(), 3);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn trailing_zeros(self) -> u32 {
unsafe { $cttz(self as $ActualT) as u32 }
///
/// assert_eq!(n.rotate_left(12), m);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn rotate_left(self, n: u32) -> $T {
// Protect against undefined behaviour for over-long bit shifts
///
/// assert_eq!(n.rotate_right(12), m);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn rotate_right(self, n: u32) -> $T {
// Protect against undefined behaviour for over-long bit shifts
pub fn saturating_add(self, other: $T) -> $T {
match self.checked_add(other) {
Some(x) => x,
- None if other >= <$T>::zero() => <$T>::max_value(),
- None => <$T>::min_value(),
+ None if other >= <$T as Zero>::zero() => <$T>::max_value(),
+ None => <$T>::min_value(),
}
}
pub fn saturating_sub(self, other: $T) -> $T {
match self.checked_sub(other) {
Some(x) => x,
- None if other >= <$T>::zero() => <$T>::min_value(),
- None => <$T>::max_value(),
+ None if other >= <$T as Zero>::zero() => <$T>::min_value(),
+ None => <$T>::max_value(),
+ }
+ }
+
+ /// Wrapping (modular) addition. Computes `self + other`,
+ /// wrapping around at the boundary of the type.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_add(self, rhs: $T) -> $T {
+ unsafe {
+ intrinsics::overflowing_add(self, rhs)
+ }
+ }
+
+ /// Wrapping (modular) subtraction. Computes `self - other`,
+ /// wrapping around at the boundary of the type.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_sub(self, rhs: $T) -> $T {
+ unsafe {
+ intrinsics::overflowing_sub(self, rhs)
+ }
+ }
+
+ /// Wrapping (modular) multiplication. Computes `self *
+ /// other`, wrapping around at the boundary of the type.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[inline]
+ pub fn wrapping_mul(self, rhs: $T) -> $T {
+ unsafe {
+ intrinsics::overflowing_mul(self, rhs)
}
}
///
/// assert_eq!(2.pow(4), 16);
/// ```
- #[unstable(feature = "core",
- reason = "pending integer conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn pow(self, mut exp: u32) -> $T {
let mut base = self;
- let mut acc = <$T>::one();
+ let mut acc = <$T as One>::one();
let mut prev_base = self;
let mut base_oflo = false;
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_power_of_two(self) -> bool {
- (self.wrapping_sub(<$T>::one())) & self == <$T>::zero() &&
- !(self == <$T>::zero())
+ (self.wrapping_sub(<$T as One>::one())) & self == <$T as Zero>::zero() &&
+ !(self == <$T as Zero>::zero())
}
/// Returns the smallest power of two greater than or equal to `self`.
#[inline]
pub fn next_power_of_two(self) -> $T {
let bits = size_of::<$T>() * 8;
- let one: $T = <$T>::one();
+ let one: $T = <$T as One>::one();
one << ((bits - self.wrapping_sub(one).leading_zeros() as usize) % bits)
}
#[cfg(target_pointer_width = "32")]
#[lang = "usize"]
impl usize {
- uint_impl! { uint = u32, 32,
+ uint_impl! { usize = u32, 32,
intrinsics::ctpop32,
intrinsics::ctlz32,
intrinsics::cttz32,
#[cfg(target_pointer_width = "64")]
#[lang = "usize"]
impl usize {
- uint_impl! { uint = u64, 64,
+ uint_impl! { usize = u64, 64,
intrinsics::ctpop64,
intrinsics::ctlz64,
intrinsics::cttz64,
/// A generic trait for converting a value to a number.
#[unstable(feature = "core", reason = "trait is likely to be removed")]
pub trait ToPrimitive {
- /// Converts the value of `self` to an `int`.
+ /// Converts the value of `self` to an `isize`.
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0", reason = "use to_isize")]
- fn to_int(&self) -> Option<int> {
+ fn to_int(&self) -> Option<isize> {
self.to_i64().and_then(|x| x.to_isize())
}
/// Converts the value of `self` to an `i64`.
fn to_i64(&self) -> Option<i64>;
- /// Converts the value of `self` to an `uint`.
+ /// Converts the value of `self` to an `usize`.
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0", reason = "use to_usize")]
- fn to_uint(&self) -> Option<uint> {
+ fn to_uint(&self) -> Option<usize> {
self.to_u64().and_then(|x| x.to_usize())
}
($T:ty) => (
impl ToPrimitive for $T {
#[inline]
- fn to_int(&self) -> Option<int> { impl_to_primitive_int_to_int!($T, int, *self) }
+ fn to_int(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
#[inline]
fn to_isize(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
#[inline]
fn to_i64(&self) -> Option<i64> { impl_to_primitive_int_to_int!($T, i64, *self) }
#[inline]
- fn to_uint(&self) -> Option<uint> { impl_to_primitive_int_to_uint!($T, uint, *self) }
+ fn to_uint(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
#[inline]
fn to_usize(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
#[inline]
($T:ty) => (
impl ToPrimitive for $T {
#[inline]
- fn to_int(&self) -> Option<int> { impl_to_primitive_uint_to_int!(int, *self) }
+ fn to_int(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
#[inline]
- fn to_isize(&self) -> Option<int> { impl_to_primitive_uint_to_int!(isize, *self) }
+ fn to_isize(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
#[inline]
fn to_i8(&self) -> Option<i8> { impl_to_primitive_uint_to_int!(i8, *self) }
#[inline]
fn to_i64(&self) -> Option<i64> { impl_to_primitive_uint_to_int!(i64, *self) }
#[inline]
- fn to_uint(&self) -> Option<uint> { impl_to_primitive_uint_to_uint!($T, uint, *self) }
+ fn to_uint(&self) -> Option<usize> { impl_to_primitive_uint_to_uint!($T, usize, *self) }
#[inline]
- fn to_usize(&self) -> Option<uint> { impl_to_primitive_uint_to_uint!($T, usize, *self) }
+ fn to_usize(&self) -> Option<usize> {
+ impl_to_primitive_uint_to_uint!($T, usize, *self)
+ }
#[inline]
fn to_u8(&self) -> Option<u8> { impl_to_primitive_uint_to_uint!($T, u8, *self) }
#[inline]
($T:ident) => (
impl ToPrimitive for $T {
#[inline]
- fn to_int(&self) -> Option<int> { Some(*self as int) }
+ fn to_int(&self) -> Option<isize> { Some(*self as isize) }
#[inline]
- fn to_isize(&self) -> Option<int> { Some(*self as isize) }
+ fn to_isize(&self) -> Option<isize> { Some(*self as isize) }
#[inline]
fn to_i8(&self) -> Option<i8> { Some(*self as i8) }
#[inline]
fn to_i64(&self) -> Option<i64> { Some(*self as i64) }
#[inline]
- fn to_uint(&self) -> Option<uint> { Some(*self as uint) }
+ fn to_uint(&self) -> Option<usize> { Some(*self as usize) }
#[inline]
- fn to_usize(&self) -> Option<uint> { Some(*self as usize) }
+ fn to_usize(&self) -> Option<usize> { Some(*self as usize) }
#[inline]
fn to_u8(&self) -> Option<u8> { Some(*self as u8) }
#[inline]
/// A generic trait for converting a number to a value.
#[unstable(feature = "core", reason = "trait is likely to be removed")]
pub trait FromPrimitive : ::marker::Sized {
- /// Convert an `int` to return an optional value of this type. If the
+ /// Convert an `isize` to return an optional value of this type. If the
/// value cannot be represented by this value, the `None` is returned.
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0", reason = "use from_isize")]
- fn from_int(n: int) -> Option<Self> {
+ fn from_int(n: isize) -> Option<Self> {
FromPrimitive::from_i64(n as i64)
}
/// type cannot be represented by this value, the `None` is returned.
fn from_i64(n: i64) -> Option<Self>;
- /// Convert an `uint` to return an optional value of this type. If the
+ /// Convert an `usize` to return an optional value of this type. If the
/// type cannot be represented by this value, the `None` is returned.
#[inline]
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0", reason = "use from_usize")]
- fn from_uint(n: uint) -> Option<Self> {
+ fn from_uint(n: usize) -> Option<Self> {
FromPrimitive::from_u64(n as u64)
}
/// A utility function that just calls `FromPrimitive::from_int`.
#[unstable(feature = "core", reason = "likely to be removed")]
#[deprecated(since = "1.0.0", reason = "use from_isize")]
-pub fn from_int<A: FromPrimitive>(n: i
nt) -> Option<A> {
+pub fn from_int<A: FromPrimitive>(n: i
size) -> Option<A> {
FromPrimitive::from_isize(n)
}
/// A utility function that just calls `FromPrimitive::from_uint`.
#[unstable(feature = "core", reason = "likely to be removed")]
#[deprecated(since = "1.0.0", reason = "use from_uint")]
-pub fn from_uint<A: FromPrimitive>(n: u
int) -> Option<A> {
+pub fn from_uint<A: FromPrimitive>(n: u
size) -> Option<A> {
FromPrimitive::from_usize(n)
}
($T:ty, $to_ty:ident) => (
#[allow(deprecated)]
impl FromPrimitive for $T {
- #[inline] fn from_int(n: int) -> Option<$T> { n.$to_ty() }
+ #[inline] fn from_int(n: isize) -> Option<$T> { n.$to_ty() }
#[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() }
#[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() }
#[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() }
#[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() }
- #[inline] fn from_uint(n: uint) -> Option<$T> { n.$to_ty() }
+ #[inline] fn from_uint(n: usize) -> Option<$T> { n.$to_ty() }
#[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() }
#[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() }
#[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() }
)
}
-impl_from_primitive! { int, to_int }
+impl_from_primitive! { isize, to_int }
impl_from_primitive! { i8, to_i8 }
impl_from_primitive! { i16, to_i16 }
impl_from_primitive! { i32, to_i32 }
impl_from_primitive! { i64, to_i64 }
-impl_from_primitive! { uint, to_uint }
+impl_from_primitive! { usize, to_uint }
impl_from_primitive! { u8, to_u8 }
impl_from_primitive! { u16, to_u16 }
impl_from_primitive! { u32, to_u32 }
impl_num_cast! { u16, to_u16 }
impl_num_cast! { u32, to_u32 }
impl_num_cast! { u64, to_u64 }
-impl_num_cast! { uint, to_uint }
+impl_num_cast! { usize, to_uint }
impl_num_cast! { i8, to_i8 }
impl_num_cast! { i16, to_i16 }
impl_num_cast! { i32, to_i32 }
impl_num_cast! { i64, to_i64 }
-impl_num_cast! { int, to_int }
+impl_num_cast! { isize, to_int }
impl_num_cast! { f32, to_f32 }
impl_num_cast! { f64, to_f64 }
/// Used for representing the classification of floating point numbers
#[derive(Copy, PartialEq, Debug)]
-#[unstable(feature = "core", reason = "may be renamed")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub enum FpCategory {
/// "Not a Number", often obtained by dividing by zero
+ #[stable(feature = "rust1", since = "1.0.0")]
Nan,
+
/// Positive or negative infinity
+ #[stable(feature = "rust1", since = "1.0.0")]
Infinite ,
+
/// Positive or negative zero
+ #[stable(feature = "rust1", since = "1.0.0")]
Zero,
+
/// De-normalized floating point representation (less precise than `Normal`)
+ #[stable(feature = "rust1", since = "1.0.0")]
Subnormal,
+
/// A regular floating point number
+ #[stable(feature = "rust1", since = "1.0.0")]
Normal,
}
#[deprecated(since = "1.0.0",
reason = "use `std::f32::MANTISSA_DIGITS` or \
`std::f64::MANTISSA_DIGITS` as appropriate")]
- fn mantissa_digits(unused_self: Option<Self>) -> uint;
+ fn mantissa_digits(unused_self: Option<Self>) -> usize;
/// Returns the number of base-10 digits of precision that this type supports.
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")]
- fn digits(unused_self: Option<Self>) -> uint;
+ fn digits(unused_self: Option<Self>) -> usize;
/// Returns the difference between 1.0 and the smallest representable number larger than 1.0.
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")]
- fn min_exp(unused_self: Option<Self>) -> int;
+ fn min_exp(unused_self: Option<Self>) -> isize;
/// Returns the maximum binary exponent that this type can represent.
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")]
- fn max_exp(unused_self: Option<Self>) -> int;
+ fn max_exp(unused_self: Option<Self>) -> isize;
/// Returns the minimum base-10 exponent that this type can represent.
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")]
- fn min_10_exp(unused_self: Option<Self>) -> int;
+ fn min_10_exp(unused_self: Option<Self>) -> isize;
/// Returns the maximum base-10 exponent that this type can represent.
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")]
- fn max_10_exp(unused_self: Option<Self>) -> int;
+ fn max_10_exp(unused_self: Option<Self>) -> isize;
/// Returns the smallest finite value that this type can represent.
#[unstable(feature = "core")]
#[deprecated(since = "1.0.0",
/// A generic trait for converting a string with a radix (base) to a value
#[unstable(feature = "core", reason = "needs reevaluation")]
+#[deprecated(since = "1.0.0",
+ reason = "moved to inherent methods; use e.g. i32::from_str_radix")]
pub trait FromStrRadix {
+ #[unstable(feature = "core", reason = "needs reevaluation")]
+ #[deprecated(since = "1.0.0", reason = "moved to inherent methods")]
type Err;
+
+ #[unstable(feature = "core", reason = "needs reevaluation")]
+ #[deprecated(since = "1.0.0",
+ reason = "moved to inherent methods; use e.g. i32::from_str_radix")]
+ #[allow(deprecated)]
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::Err>;
}
/// A utility function that just calls `FromStrRadix::from_str_radix`.
#[unstable(feature = "core", reason = "needs reevaluation")]
+#[deprecated(since = "1.0.0", reason = "use e.g. i32::from_str_radix")]
+#[allow(deprecated)]
pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: u32)
-> Result<T, T::Err> {
FromStrRadix::from_str_radix(str, radix)
/// `None` if the string did not represent a valid number. Otherwise,
/// `Some(n)` where `n` is the floating-point number represented by `src`.
#[inline]
+ #[allow(deprecated)]
fn from_str(src: &str) -> Result<$T, ParseFloatError> {
from_str_radix(src, 10)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
impl FromStrRadix for $T {
type Err = ParseFloatError;
let mut prev_sig = sig;
let mut cs = src.chars().enumerate();
// Exponent prefix and exponent index offset
- let mut exp_info = None::<(char, uint)>;
+ let mut exp_info = None::<(char, usize)>;
// Parse the integer part of the significand
for (i, c) in cs.by_ref() {
// add/subtract current digit depending on sign
if is_positive {
- sig = sig + ((digit as int) as $T);
+ sig = sig + ((digit as isize) as $T);
} else {
- sig = sig - ((digit as int) as $T);
+ sig = sig - ((digit as isize) as $T);
}
// Detect overflow by comparing to last value, except
// Parse the exponent as decimal integer
let src = &src[offset..];
let (is_positive, exp) = match src.slice_shift_char() {
- Some(('-', src)) => (false, src.parse::<uint>()),
- Some(('+', src)) => (true, src.parse::<uint>()),
- Some((_, _)) => (true, src.parse::<uint>()),
+ Some(('-', src)) => (false, src.parse::<usize>()),
+ Some(('+', src)) => (true, src.parse::<usize>()),
+ Some((_, _)) => (true, src.parse::<usize>()),
None => return Err(PFE { kind: Invalid }),
};
macro_rules! from_str_radix_int_impl {
($T:ty) => {
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
impl FromStr for $T {
type Err = ParseIntError;
#[inline]
}
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(deprecated)]
impl FromStrRadix for $T {
type Err = ParseIntError;
fn from_str_radix(src: &str, radix: u32)
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "u16")]
-#![allow(trivial_numeric_casts)]
uint_module! { u16, i16, 16 }
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "u32")]
-#![allow(trivial_numeric_casts)]
uint_module! { u32, i32, 32 }
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "u64")]
-#![allow(trivial_numeric_casts)]
uint_module! { u64, i64, 64 }
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "u8")]
-#![allow(trivial_numeric_casts)]
uint_module! { u8, i8, 8 }
// except according to those terms.
#![doc(hidden)]
-#![allow(trivial_numeric_casts)]
macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
#![stable(feature = "rust1", since = "1.0.0")]
#![doc(primitive = "usize")]
-#![allow(trivial_numeric_casts)]
uint_module! { usize, isize, ::isize::BITS }
// <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.
+
#![allow(missing_docs)]
+#![allow(deprecated)]
+
+use super::Wrapping;
use ops::*;
use intrinsics::{i32_mul_with_overflow, u32_mul_with_overflow};
use intrinsics::{i64_mul_with_overflow, u64_mul_with_overflow};
+#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")]
+#[deprecated(since = "1.0.0", reason = "moved to inherent methods")]
pub trait WrappingOps {
fn wrapping_add(self, rhs: Self) -> Self;
fn wrapping_sub(self, rhs: Self) -> Self;
fn overflowing_mul(self, rhs: Self) -> (Self, bool);
}
+macro_rules! sh_impl {
+ ($t:ty, $f:ty) => (
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Shl<$f> for Wrapping<$t> {
+ type Output = Wrapping<$t>;
+
+ #[inline(always)]
+ fn shl(self, other: $f) -> Wrapping<$t> {
+ Wrapping(self.0 << other)
+ }
+ }
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Shr<$f> for Wrapping<$t> {
+ type Output = Wrapping<$t>;
+
+ #[inline(always)]
+ fn shr(self, other: $f) -> Wrapping<$t> {
+ Wrapping(self.0 >> other)
+ }
+ }
+ )
+}
+
+// FIXME (#23545): uncomment the remaining impls
+macro_rules! sh_impl_all {
+ ($($t:ty)*) => ($(
+ // sh_impl! { $t, u8 }
+ // sh_impl! { $t, u16 }
+ // sh_impl! { $t, u32 }
+ // sh_impl! { $t, u64 }
+ sh_impl! { $t, usize }
+
+ // sh_impl! { $t, i8 }
+ // sh_impl! { $t, i16 }
+ // sh_impl! { $t, i32 }
+ // sh_impl! { $t, i64 }
+ // sh_impl! { $t, isize }
+ )*)
+}
+
+sh_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize }
+
macro_rules! wrapping_impl {
($($t:ty)*) => ($(
impl WrappingOps for $t {
}
}
}
- )*)
-}
-
-wrapping_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
-
-#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")]
-#[derive(PartialEq,Eq,PartialOrd,Ord,Clone,Copy)]
-pub struct Wrapping<T>(pub T);
-
-impl<T:WrappingOps> Add for Wrapping<T> {
- type Output = Wrapping<T>;
-
- #[inline(always)]
- fn add(self, other: Wrapping<T>) -> Wrapping<T> {
- Wrapping(self.0.wrapping_add(other.0))
- }
-}
-impl<T:WrappingOps> Sub for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Add for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- #[inline(always)]
- fn sub(self, other: Wrapping<T>) -> Wrapping<T> {
- Wrapping(self.0.wrapping_sub(other.0))
- }
-}
+ #[inline(always)]
+ fn add(self, other: Wrapping<$t>) -> Wrapping<$t> {
+ Wrapping(self.0.wrapping_add(other.0))
+ }
+ }
-impl<T:WrappingOps> Mul for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Sub for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- #[inline(always)]
- fn mul(self, other: Wrapping<T>) -> Wrapping<T> {
- Wrapping(self.0.wrapping_mul(other.0))
- }
-}
+ #[inline(always)]
+ fn sub(self, other: Wrapping<$t>) -> Wrapping<$t> {
+ Wrapping(self.0.wrapping_sub(other.0))
+ }
+ }
-impl<T:WrappingOps+Not<Output=T>> Not for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Mul for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- fn not(self) -> Wrapping<T> {
- Wrapping(!self.0)
- }
-}
+ #[inline(always)]
+ fn mul(self, other: Wrapping<$t>) -> Wrapping<$t> {
+ Wrapping(self.0.wrapping_mul(other.0))
+ }
+ }
-impl<T:WrappingOps+BitXor<Output=T>> BitXor for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl Not for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- #[inline(always)]
- fn bitxor(self, other: Wrapping<T>) -> Wrapping<T> {
- Wrapping(self.0 ^ other.0)
- }
-}
+ fn not(self) -> Wrapping<$t> {
+ Wrapping(!self.0)
+ }
+ }
-impl<T:WrappingOps+BitOr<Output=T>> BitOr for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl BitXor for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- #[inline(always)]
- fn bitor(self, other: Wrapping<T>) -> Wrapping<T> {
- Wrapping(self.0 | other.0)
- }
-}
+ #[inline(always)]
+ fn bitxor(self, other: Wrapping<$t>) -> Wrapping<$t> {
+ Wrapping(self.0 ^ other.0)
+ }
+ }
-impl<T:WrappingOps+BitAnd<Output=T>> BitAnd for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl BitOr for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- #[inline(always)]
- fn bitand(self, other: Wrapping<T>) -> Wrapping<T> {
- Wrapping(self.0 & other.0)
- }
-}
+ #[inline(always)]
+ fn bitor(self, other: Wrapping<$t>) -> Wrapping<$t> {
+ Wrapping(self.0 | other.0)
+ }
+ }
-impl<T:WrappingOps+Shl<uint,Output=T>> Shl<uint> for Wrapping<T> {
- type Output = Wrapping<T>;
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl BitAnd for Wrapping<$t> {
+ type Output = Wrapping<$t>;
- #[inline(always)]
- fn shl(self, other: uint) -> Wrapping<T> {
- Wrapping(self.0 << other)
- }
+ #[inline(always)]
+ fn bitand(self, other: Wrapping<$t>) -> Wrapping<$t> {
+ Wrapping(self.0 & other.0)
+ }
+ }
+ )*)
}
-impl<T:WrappingOps+Shr<uint,Output=T>> Shr<uint> for Wrapping<T> {
- type Output = Wrapping<T>;
-
- #[inline(always)]
- fn shr(self, other: uint) -> Wrapping<T> {
- Wrapping(self.0 >> other)
- }
-}
+wrapping_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
macro_rules! overflowing_impl {
($($t:ident)*) => ($(
macro_rules! neg_impl {
($($t:ty)*) => ($(
#[stable(feature = "rust1", since = "1.0.0")]
+ #[allow(unsigned_negation)]
impl Neg for $t {
#[stable(feature = "rust1", since = "1.0.0")]
type Output = $t;
)*)
}
-macro_rules! neg_uint_impl {
- ($t:ty, $t_signed:ty) => {
- #[stable(feature = "rust1", since = "1.0.0")]
- impl Neg for $t {
- type Output = $t;
-
- #[inline]
- fn neg(self) -> $t { -(self as $t_signed) as $t }
- }
-
- forward_ref_unop! { impl Neg, neg for $t }
- }
-}
-
-neg_impl! { isize i8 i16 i32 i64 f32 f64 }
-
-neg_uint_impl! { usize, isize }
-neg_uint_impl! { u8, i8 }
-neg_uint_impl! { u16, i16 }
-neg_uint_impl! { u32, i32 }
-neg_uint_impl! { u64, i64 }
-
+neg_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
/// The `Not` trait is used to specify the functionality of unary `!`.
///
type Output: ?Sized;
/// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- fn index<'a>(&'a self, index: &Idx) -> &'a Self::Output;
-
- /// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
fn index<'a>(&'a self, index: Idx) -> &'a Self::Output;
}
#[stable(feature = "rust1", since = "1.0.0")]
pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
/// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- fn index_mut<'a>(&'a mut self, index: &Idx) -> &'a mut Self::Output;
-
- /// The method for the indexing (`Foo[Bar]`) operation
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
fn index_mut<'a>(&'a mut self, index: Idx) -> &'a mut Self::Output;
}
#[lang="fn"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
-#[cfg(stage0)]
-pub trait Fn<Args> {
- /// The returned type after the call operator is used.
- type Output;
-
- /// This is called when the call operator is used.
- extern "rust-call" fn call(&self, args: Args) -> Self::Output;
-}
-
-/// A version of the call operator that takes an immutable receiver.
-#[lang="fn"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_paren_sugar]
-#[cfg(not(stage0))]
pub trait Fn<Args> : FnMut<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
#[lang="fn_mut"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
-#[cfg(stage0)]
-pub trait FnMut<Args> {
- /// The returned type after the call operator is used.
- type Output;
-
- /// This is called when the call operator is used.
- extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
-}
-
-/// A version of the call operator that takes a mutable receiver.
-#[lang="fn_mut"]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_paren_sugar]
-#[cfg(not(stage0))]
pub trait FnMut<Args> : FnOnce<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
/// This is called when the call operator is used.
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}
-
-#[cfg(stage0)]
-impl<F: ?Sized, A> FnMut<A> for F
- where F : Fn<A>
-{
- type Output = <F as Fn<A>>::Output;
-
- extern "rust-call" fn call_mut(&mut self, args: A) -> <F as Fn<A>>::Output {
- self.call(args)
- }
-}
-
-#[cfg(stage0)]
-impl<F,A> FnOnce<A> for F
- where F : FnMut<A>
-{
- type Output = <F as FnMut<A>>::Output;
-
- extern "rust-call" fn call_once(mut self, args: A) -> <F as FnMut<A>>::Output {
- self.call_mut(args)
- }
-}
use clone::Clone;
use cmp::{Eq, Ord};
use default::Default;
-use iter::{ExactSizeIterator};
-use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator, IntoIterator};
+use iter::ExactSizeIterator;
+use iter::{Iterator, DoubleEndedIterator, FromIterator, IntoIterator};
use mem;
-use ops::{Deref, FnOnce};
+use ops::FnOnce;
use result::Result::{Ok, Err};
use result::Result;
#[allow(deprecated)]
/// assert_eq!(x.expect("the world is ending"), "value");
/// ```
///
- /// ```{.should_fail}
+ /// ```{.should_panic}
/// let x: Option<&str> = None;
/// x.expect("the world is ending"); // panics with `world is ending`
/// ```
}
}
- /// Returns the inner `T` of a `Some(T)`.
+ /// Moves the value `v` out of the `Option<T>` if it is `Some(v)`.
///
/// # Panics
///
/// assert_eq!(x.unwrap(), "air");
/// ```
///
- /// ```{.should_fail}
+ /// ```{.should_panic}
/// let x: Option<&str> = None;
/// assert_eq!(x.unwrap(), "air"); // fails
/// ```
/// assert_eq!(x.ok_or(0), Err(0));
/// ```
#[inline]
- #[unstable(feature = "core")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn ok_or<E>(self, err: E) -> Result<T, E> {
match self {
Some(v) => Ok(v),
/// assert_eq!(x.ok_or_else(|| 0), Err(0));
/// ```
#[inline]
- #[unstable(feature = "core")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {
match self {
Some(v) => Ok(v),
/// assert_eq!(x.iter_mut().next(), None);
/// ```
#[inline]
- #[unstable(feature = "core",
- reason = "waiting for iterator conventions")]
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<T> {
IterMut { inner: Item { opt: self.as_mut() } }
}
}
}
-impl<'a, T: Clone, D: Deref<Target=T>> Option<D> {
- /// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option.
- /// Useful for converting an Option<&T> to an Option<T>.
- #[unstable(feature = "core",
- reason = "recently added as part of collections reform")]
+impl<'a, T: Clone> Option<&'a T> {
+ /// Maps an Option<&T> to an Option<T> by cloning the contents of the Option.
+ #[stable(feature = "rust1", since = "1.0.0")]
pub fn cloned(self) -> Option<T> {
- self.map(|t| t.deref().clone())
+ self.map(|t| t.clone())
}
}
//! interface for panicking is:
//!
//! ```ignore
-//! fn panic_impl(fmt: fmt::Arguments, &(&'static str, uint)) -> !;
+//! fn panic_impl(fmt: fmt::Arguments, &(&'static str, usize)) -> !;
//! ```
//!
//! This definition allows for panicking with any general message, but it does not
#[allow(improper_ctypes)]
extern {
#[lang = "panic_fmt"]
- fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: uint) -> !;
+ fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: usize) -> !;
}
let (file, line) = *file_line;
- unsafe { panic_impl(fmt, file, line as uint) }
+ unsafe { panic_impl(fmt, file, line as usize) }
}
pub use clone::Clone;
pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
pub use convert::{AsRef, AsMut, Into, From};
-pub use iter::{Extend, IteratorExt};
+pub use iter::Extend;
pub use iter::{Iterator, DoubleEndedIterator};
pub use iter::{ExactSizeIterator};
pub use option::Option::{self, Some, None};
// FIXME #19649: intrinsic docs don't render, so these have no docs :(
#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(not(stage0))]
pub use intrinsics::copy_nonoverlapping;
+/// dox
+#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
+pub unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize) {
+ intrinsics::copy_nonoverlapping(dst, src, count)
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(not(stage0))]
pub use intrinsics::copy;
+/// dox
+#[cfg(stage0)]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
+ intrinsics::copy(dst, src, count)
+}
+
+
#[stable(feature = "rust1", since = "1.0.0")]
pub use intrinsics::write_bytes;
pub unsafe fn swap<T>(x: *mut T, y: *mut T) {
// Give ourselves some scratch space to work with
let mut tmp: T = mem::uninitialized();
- let t: *mut T = &mut tmp;
// Perform the swap
- copy_nonoverlapping(t, &*x, 1);
- copy(x, &*y, 1); // `x` and `y` may overlap
- copy_nonoverlapping(y, &*t, 1);
+ copy_nonoverlapping(x, &mut tmp, 1);
+ copy(y, x, 1); // `x` and `y` may overlap
+ copy_nonoverlapping(&tmp, y, 1);
// y and t now point to the same thing, but we need to completely forget `tmp`
// because it's no longer relevant.
#[stable(feature = "rust1", since = "1.0.0")]
pub unsafe fn read<T>(src: *const T) -> T {
let mut tmp: T = mem::uninitialized();
- copy_nonoverlapping(&mut tmp, src, 1);
+ copy_nonoverlapping(src, &mut tmp, 1);
tmp
}
tmp
}
+/// Variant of read_and_zero that writes the specific drop-flag byte
+/// (which may be more appropriate than zero).
+#[inline(always)]
+#[unstable(feature = "core",
+ reason = "may play a larger role in std::ptr future extensions")]
+pub unsafe fn read_and_drop<T>(dest: *mut T) -> T {
+ // Copy the data out from `dest`:
+ let tmp = read(&*dest);
+
+ // Now mark `dest` as dropped:
+ write_bytes(dest, mem::POST_DROP_U8, 1);
+
+ tmp
+}
+
/// Overwrites a memory location with the given value without reading or
/// dropping the old value.
///
//! that make working with it more succinct.
//!
//! ```
-//! let good_result: Result<int, int> = Ok(10);
-//! let bad_result: Result<int, int> = Err(10);
+//! let good_result: Result<i32, i32> = Ok(10);
+//! let bad_result: Result<i32, i32> = Err(10);
//!
//! // The `is_ok` and `is_err` methods do what they say.
//! assert!(good_result.is_ok() && !good_result.is_err());
//! assert!(bad_result.is_err() && !bad_result.is_ok());
//!
//! // `map` consumes the `Result` and produces another.
-//! let good_result: Result<int, int> = good_result.map(|i| i + 1);
-//! let bad_result: Result<int, int> = bad_result.map(|i| i - 1);
+//! let good_result: Result<i32, i32> = good_result.map(|i| i + 1);
+//! let bad_result: Result<i32, i32> = bad_result.map(|i| i - 1);
//!
//! // Use `and_then` to continue the computation.
-//! let good_result: Result<bool, int> = good_result.and_then(|i| Ok(i == 11));
+//! let good_result: Result<bool, i32> = good_result.and_then(|i| Ok(i == 11));
//!
//! // Use `or_else` to handle the error.
-//! let bad_result: Result<int, int> = bad_result.or_else(|i| Ok(11));
+//! let bad_result: Result<i32, i32> = bad_result.or_else(|i| Ok(11));
//!
//! // Consume the result and return the contents with `unwrap`.
//! let final_awesome_result = good_result.unwrap();
//! useful value.
//!
//! Consider the `write_line` method defined for I/O types
-//! by the [`Writer`](../io/trait.Writer.html) trait:
+//! by the [`Writer`](../old_io/trait.Writer.html) trait:
//!
//! ```
//! # #![feature(old_io)]
//!
//! struct Info {
//! name: String,
-//! age: int,
-//! rating: int
+//! age: i32,
+//! rating: i32,
//! }
//!
//! fn write_info(info: &Info) -> Result<(), IoError> {
//!
//! struct Info {
//! name: String,
-//! age: int,
-//! rating: int
+//! age: i32,
+//! rating: i32,
//! }
//!
//! fn write_info(info: &Info) -> Result<(), IoError> {
use clone::Clone;
use fmt;
-use iter::{Iterator, IteratorExt, DoubleEndedIterator,
- FromIterator, ExactSizeIterator, IntoIterator};
+use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSizeIterator, IntoIterator};
use ops::{FnMut, FnOnce};
use option::Option::{self, None, Some};
#[allow(deprecated)]
/// # Examples
///
/// ```
- /// let x: Result<int, &str> = Ok(-3);
+ /// let x: Result<i32, &str> = Ok(-3);
/// assert_eq!(x.is_ok(), true);
///
- /// let x: Result<int, &str> = Err("Some error message");
+ /// let x: Result<i32, &str> = Err("Some error message");
/// assert_eq!(x.is_ok(), false);
/// ```
#[inline]
/// # Examples
///
/// ```
- /// let x: Result<int, &str> = Ok(-3);
+ /// let x: Result<i32, &str> = Ok(-3);
/// assert_eq!(x.is_err(), false);
///
- /// let x: Result<int, &str> = Err("Some error message");
+ /// let x: Result<i32, &str> = Err("Some error message");
/// assert_eq!(x.is_err(), true);
/// ```
#[inline]
/// Convert from `Result<T, E>` to `Result<&mut T, &mut E>`
///
/// ```
- /// fn mutate(r: &mut Result<int, int>) {
+ /// fn mutate(r: &mut Result<i32, i32>) {
/// match r.as_mut() {
/// Ok(&mut ref mut v) => *v = 42,
/// Err(&mut ref mut e) => *e = 0,
/// }
/// }
///
- /// let mut x: Result<int, int> = Ok(2);
+ /// let mut x: Result<i32, i32> = Ok(2);
/// mutate(&mut x);
/// assert_eq!(x.unwrap(), 42);
///
- /// let mut x: Result<int, int> = Err(13);
+ /// let mut x: Result<i32, i32> = Err(13);
/// mutate(&mut x);
/// assert_eq!(x.unwrap_err(), 0);
/// ```
/// while !buffer.is_empty() {
/// let line: IoResult<String> = buffer.read_line();
/// // Convert the string line to a number using `map` and `from_str`
- /// let val: IoResult<int> = line.map(|line| {
- /// line.trim_right().parse::<int>().unwrap_or(0)
+ /// let val: IoResult<i32> = line.map(|line| {
+ /// line.trim_right().parse::<i32>().unwrap_or(0)
/// });
/// // Add the value if there were no errors, otherwise add 0
/// sum += val.unwrap_or(0);
/// assert_eq!(x.unwrap(), 2);
/// ```
///
- /// ```{.should_fail}
+ /// ```{.should_panic}
/// let x: Result<u32, &str> = Err("emergency failure");
/// x.unwrap(); // panics with `emergency failure`
/// ```
///
/// # Examples
///
- /// ```{.should_fail}
+ /// ```{.should_panic}
/// let x: Result<u32, &str> = Ok(2);
/// x.unwrap_err(); // panics with `2`
/// ```
fn len(&self) -> usize;
fn is_empty(&self) -> bool { self.len() == 0 }
fn get_mut<'a>(&'a mut self, index: usize) -> Option<&'a mut Self::Item>;
+ #[unstable(feature = "core",
+ reason = "will be replaced by slice syntax")]
+ #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
fn as_mut_slice<'a>(&'a mut self) -> &'a mut [Self::Item];
fn iter_mut<'a>(&'a mut self) -> IterMut<'a, Self::Item>;
fn first_mut<'a>(&'a mut self) -> Option<&'a mut Self::Item>;
}
#[inline]
+ #[unstable(feature = "core",
+ reason = "will be replaced by slice syntax")]
+ #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
fn as_mut_slice(&mut self) -> &mut [T] { self }
- #[cfg(stage0)]
- #[inline]
- fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
- unsafe {
- let self2: &mut [T] = mem::transmute_copy(&self);
-
- (ops::IndexMut::index_mut(self, &ops::RangeTo { end: mid } ),
- ops::IndexMut::index_mut(self2, &ops::RangeFrom { start: mid } ))
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
unsafe {
impl<T> ops::Index<usize> for [T] {
type Output = T;
- #[cfg(stage0)]
- fn index(&self, &index: &usize) -> &T {
- assert!(index < self.len());
-
- unsafe { mem::transmute(self.repr().data.offset(index as isize)) }
- }
-
- #[cfg(not(stage0))]
fn index(&self, index: usize) -> &T {
assert!(index < self.len());
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<usize> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, &index: &usize) -> &mut T {
- assert!(index < self.len());
-
- unsafe { mem::transmute(self.repr().data.offset(index as isize)) }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
assert!(index < self.len());
impl<T> ops::Index<ops::Range<usize>> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- assert!(index.start <= index.end);
- assert!(index.end <= self.len());
- unsafe {
- from_raw_parts (
- self.as_ptr().offset(index.start as isize),
- index.end - index.start
- )
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
assert!(index.start <= index.end);
impl<T> ops::Index<ops::RangeTo<usize>> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- self.index(&ops::Range{ start: 0, end: index.end })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.index(ops::Range{ start: 0, end: index.end })
impl<T> ops::Index<ops::RangeFrom<usize>> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- self.index(&ops::Range{ start: index.start, end: self.len() })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.index(ops::Range{ start: index.start, end: self.len() })
impl<T> ops::Index<RangeFull> for [T] {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &RangeFull) -> &[T] {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
self
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<usize>> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
- assert!(index.start <= index.end);
- assert!(index.end <= self.len());
- unsafe {
- from_raw_parts_mut(
- self.as_mut_ptr().offset(index.start as isize),
- index.end - index.start
- )
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
assert!(index.start <= index.end);
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<usize>> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
- self.index_mut(&ops::Range{ start: 0, end: index.end })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(ops::Range{ start: 0, end: index.end })
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<usize>> for [T] {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
- let len = self.len();
- self.index_mut(&ops::Range{ start: index.start, end: len })
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
let len = self.len();
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<RangeFull> for [T] {
-
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T] {
self
impl<'a, T> ops::Index<ops::Range<usize>> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- self.as_slice().index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
self.as_slice().index(index)
impl<'a, T> ops::Index<ops::RangeTo<usize>> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- self.as_slice().index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.as_slice().index(index)
impl<'a, T> ops::Index<ops::RangeFrom<usize>> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- self.as_slice().index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.as_slice().index(index)
impl<'a, T> ops::Index<RangeFull> for Iter<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &RangeFull) -> &[T] {
- self.as_slice()
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
self.as_slice()
impl<'a, T> ops::Index<ops::Range<usize>> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &[T] {
- self.index(&RangeFull).index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
self.index(RangeFull).index(index)
impl<'a, T> ops::Index<ops::RangeTo<usize>> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
- self.index(&RangeFull).index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.index(RangeFull).index(index)
impl<'a, T> ops::Index<ops::RangeFrom<usize>> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
- self.index(&RangeFull).index(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.index(RangeFull).index(index)
impl<'a, T> ops::Index<RangeFull> for IterMut<'a, T> {
type Output = [T];
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &RangeFull) -> &[T] {
- make_slice!(T => &[T]: self.ptr, self.end)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
make_slice!(T => &[T]: self.ptr, self.end)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<usize>> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
- self.index_mut(&RangeFull).index_mut(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeTo<usize>> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
- self.index_mut(&RangeFull).index_mut(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<usize>> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
- self.index_mut(&RangeFull).index_mut(index)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {
- #[cfg(stage0)]
- #[inline]
- fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
- make_mut_slice!(T => &mut [T]: self.ptr, self.end)
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T] {
make_mut_slice!(T => &mut [T]: self.ptr, self.end)
///
/// Panics if the length of `dst` is less than the length of `src`.
#[inline]
- pub fn copy_memory(dst: &mut [u8], src: &[u8]) {
+ pub fn copy_memory(src: &[u8], dst: &mut [u8]) {
let len_src = src.len();
assert!(dst.len() >= len_src);
// `dst` is unaliasable, so we know statically it doesn't overlap
// with `src`.
unsafe {
- ptr::copy_nonoverlapping(dst.as_mut_ptr(),
- src.as_ptr(),
+ ptr::copy_nonoverlapping(src.as_ptr(),
+ dst.as_mut_ptr(),
len_src);
}
}
use error::Error;
use fmt;
use iter::ExactSizeIterator;
-use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
+use iter::{Map, Iterator, DoubleEndedIterator};
use marker::Sized;
use mem;
#[allow(deprecated)]
#[derive(Copy, Clone)]
struct BytesDeref;
-#[cfg(stage0)]
-impl<'a> Fn<(&'a u8,)> for BytesDeref {
- type Output = u8;
-
- #[inline]
- extern "rust-call" fn call(&self, (ptr,): (&'a u8,)) -> u8 {
- *ptr
- }
-}
-
-#[cfg(not(stage0))]
impl<'a> Fn<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call(&self, (ptr,): (&'a u8,)) -> u8 {
}
}
-#[cfg(not(stage0))]
impl<'a> FnMut<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call_mut(&mut self, (ptr,): (&'a u8,)) -> u8 {
}
}
-#[cfg(not(stage0))]
impl<'a> FnOnce<(&'a u8,)> for BytesDeref {
type Output = u8;
// critical factorization (u, v) and p = period(v)
#[inline]
#[allow(dead_code)]
+ #[allow(deprecated)]
fn maximal_suffix(arr: &[u8], reversed: bool) -> (usize, usize) {
- use num::wrapping::WrappingOps;
- let mut left = -1; // Corresponds to i in the paper
+ let mut left: usize = -1; // Corresponds to i in the paper
let mut right = 0; // Corresponds to j in the paper
let mut offset = 1; // Corresponds to k in the paper
let mut period = 1; // Corresponds to p in the paper
mod traits {
use cmp::{Ordering, Ord, PartialEq, PartialOrd, Eq};
use cmp::Ordering::{Less, Equal, Greater};
- use iter::IteratorExt;
+ use iter::Iterator;
use option::Option;
use option::Option::Some;
use ops;
/// // byte 100 is outside the string
/// // &s[3 .. 100];
/// ```
- #[cfg(stage0)]
- #[stable(feature = "rust1", since = "1.0.0")]
- impl ops::Index<ops::Range<usize>> for str {
- type Output = str;
- #[inline]
- fn index(&self, index: &ops::Range<usize>) -> &str {
- // is_char_boundary checks that the index is in [0, .len()]
- if index.start <= index.end &&
- self.is_char_boundary(index.start) &&
- self.is_char_boundary(index.end) {
- unsafe { self.slice_unchecked(index.start, index.end) }
- } else {
- super::slice_error_fail(self, index.start, index.end)
- }
- }
- }
-
- /// Returns a slice of the given string from the byte range
- /// [`begin`..`end`).
- ///
- /// This operation is `O(1)`.
- ///
- /// Panics when `begin` and `end` do not point to valid characters
- /// or point beyond the last character of the string.
- ///
- /// # Examples
- ///
- /// ```
- /// let s = "Löwe 老虎 Léopard";
- /// assert_eq!(&s[0 .. 1], "L");
- ///
- /// assert_eq!(&s[1 .. 9], "öwe 老");
- ///
- /// // these will panic:
- /// // byte 2 lies within `ö`:
- /// // &s[2 ..3];
- ///
- /// // byte 8 lies within `老`
- /// // &s[1 .. 8];
- ///
- /// // byte 100 is outside the string
- /// // &s[3 .. 100];
- /// ```
- #[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::Range<usize>> for str {
type Output = str;
impl ops::Index<ops::RangeTo<usize>> for str {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeTo<usize>) -> &str {
- // is_char_boundary checks that the index is in [0, .len()]
- if self.is_char_boundary(index.end) {
- unsafe { self.slice_unchecked(0, index.end) }
- } else {
- super::slice_error_fail(self, 0, index.end)
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
impl ops::Index<ops::RangeFrom<usize>> for str {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
- // is_char_boundary checks that the index is in [0, .len()]
- if self.is_char_boundary(index.start) {
- unsafe { self.slice_unchecked(index.start, self.len()) }
- } else {
- super::slice_error_fail(self, index.start, self.len())
- }
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
impl ops::Index<ops::RangeFull> for str {
type Output = str;
- #[cfg(stage0)]
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &str {
- self
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &str {
self
#[inline]
unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {
mem::transmute(Slice {
- data: self.as_ptr().offset(begin as int),
+ data: self.as_ptr().offset(begin as isize),
len: end - begin,
})
}
fn any_owning() {
let (a, b, c) = (box 5_usize as Box<Any>, box TEST as Box<Any>, box Test as Box<Any>);
- assert!(a.is::<uint>());
- assert!(!b.is::<uint>());
- assert!(!c.is::<uint>());
+ assert!(a.is::<usize>());
+ assert!(!b.is::<usize>());
+ assert!(!c.is::<usize>());
assert!(!a.is::<&'static str>());
assert!(b.is::<&'static str>());
fn any_downcast_ref() {
let a = &5_usize as &Any;
- match a.downcast_ref::<uint>() {
+ match a.downcast_ref::<usize>() {
Some(&5) => {}
x => panic!("Unexpected value {:?}", x)
}
let mut b: Box<_> = box 7_usize;
let a_r = &mut a as &mut Any;
- let tmp: &mut uint = &mut *b;
+ let tmp: &mut usize = &mut *b;
let b_r = tmp as &mut Any;
- match a_r.downcast_mut::<uint>() {
+ match a_r.downcast_mut::<usize>() {
Some(x) => {
assert_eq!(*x, 5);
*x = 612;
x => panic!("Unexpected value {:?}", x)
}
- match b_r.downcast_mut::<uint>() {
+ match b_r.downcast_mut::<usize>() {
Some(x) => {
assert_eq!(*x, 7);
*x = 413;
x => panic!("Unexpected value {:?}", x)
}
- match a_r.downcast_mut::<uint>() {
+ match a_r.downcast_mut::<usize>() {
Some(&mut 612) => {}
x => panic!("Unexpected value {:?}", x)
}
- match b_r.downcast_mut::<uint>() {
+ match b_r.downcast_mut::<usize>() {
Some(&mut 413) => {}
x => panic!("Unexpected value {:?}", x)
}
fn any_fixed_vec() {
let test = [0_usize; 8];
let test = &test as &Any;
- assert!(test.is::<[uint; 8]>());
- assert!(!test.is::<[uint; 10]>());
+ assert!(test.is::<[usize; 8]>());
+ assert!(!test.is::<[usize; 10]>());
}
let mut x = 0;
let mut y = &mut x as &mut Any;
test::black_box(&mut y);
- test::black_box(y.downcast_ref::<int>() == Some(&0));
+ test::black_box(y.downcast_ref::<isize>() == Some(&0));
});
}
#[test]
fn as_unsafe_cell() {
- let c1: Cell<uint> = Cell::new(0);
+ let c1: Cell<usize> = Cell::new(0);
c1.set(1);
assert_eq!(1, unsafe { *c1.as_unsafe_cell().get() });
- let c2: Cell<uint> = Cell::new(0);
+ let c2: Cell<usize> = Cell::new(0);
unsafe { *c2.as_unsafe_cell().get() = 1; }
assert_eq!(1, c2.get());
- let r1: RefCell<uint> = RefCell::new(0);
+ let r1: RefCell<usize> = RefCell::new(0);
*r1.borrow_mut() = 1;
assert_eq!(1, unsafe { *r1.as_unsafe_cell().get() });
- let r2: RefCell<uint> = RefCell::new(0);
+ let r2: RefCell<usize> = RefCell::new(0);
unsafe { *r2.as_unsafe_cell().get() = 1; }
assert_eq!(1, *r2.borrow());
}
// Our type.
struct SketchyNum {
- num : int
+ num : isize
}
// Our implementation of `PartialEq` to support `==` and `!=`.
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_map("Foo").finish()
+ fmt.debug_map().finish()
}
}
- assert_eq!("Foo {}", format!("{:?}", Foo));
- assert_eq!("Foo {}", format!("{:#?}", Foo));
+ assert_eq!("{}", format!("{:?}", Foo));
+ assert_eq!("{}", format!("{:#?}", Foo));
}
#[test]
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_map("Foo")
+ fmt.debug_map()
.entry(&"bar", &true)
.finish()
}
}
- assert_eq!("Foo { \"bar\": true }", format!("{:?}", Foo));
+ assert_eq!("{\"bar\": true}", format!("{:?}", Foo));
assert_eq!(
-"Foo {
+"{
\"bar\": true
}",
format!("{:#?}", Foo));
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_map("Foo")
+ fmt.debug_map()
.entry(&"bar", &true)
.entry(&10i32, &format_args!("{}/{}", 10i32, 20i32))
.finish()
}
}
- assert_eq!("Foo { \"bar\": true, 10: 10/20 }", format!("{:?}", Foo));
+ assert_eq!("{\"bar\": true, 10: 10/20}", format!("{:?}", Foo));
assert_eq!(
-"Foo {
+"{
\"bar\": true,
10: 10/20
}",
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_map("Foo")
+ fmt.debug_map()
.entry(&"bar", &true)
.entry(&10i32, &format_args!("{}/{}", 10i32, 20i32))
.finish()
impl fmt::Debug for Bar {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_map("Bar")
+ fmt.debug_map()
.entry(&"foo", &Foo)
.entry(&Foo, &"world")
.finish()
}
}
- assert_eq!("Bar { \"foo\": Foo { \"bar\": true, 10: 10/20 }, \
- Foo { \"bar\": true, 10: 10/20 }: \"world\" }",
+ assert_eq!("{\"foo\": {\"bar\": true, 10: 10/20}, \
+ {\"bar\": true, 10: 10/20}: \"world\"}",
format!("{:?}", Bar));
assert_eq!(
-"Bar {
- \"foo\": Foo {
+"{
+ \"foo\": {
\"bar\": true,
10: 10/20
},
- Foo {
+ {
\"bar\": true,
10: 10/20
}: \"world\"
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_set("Foo").finish()
+ fmt.debug_set().finish()
}
}
- assert_eq!("Foo {}", format!("{:?}", Foo));
- assert_eq!("Foo {}", format!("{:#?}", Foo));
+ assert_eq!("{}", format!("{:?}", Foo));
+ assert_eq!("{}", format!("{:#?}", Foo));
}
#[test]
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_set("Foo")
+ fmt.debug_set()
.entry(&true)
.finish()
}
}
- assert_eq!("Foo { true }", format!("{:?}", Foo));
+ assert_eq!("{true}", format!("{:?}", Foo));
assert_eq!(
-"Foo {
+"{
true
}",
format!("{:#?}", Foo));
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_set("Foo")
+ fmt.debug_set()
.entry(&true)
.entry(&format_args!("{}/{}", 10i32, 20i32))
.finish()
}
}
- assert_eq!("Foo { true, 10/20 }", format!("{:?}", Foo));
+ assert_eq!("{true, 10/20}", format!("{:?}", Foo));
assert_eq!(
-"Foo {
+"{
true,
10/20
}",
impl fmt::Debug for Foo {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_set("Foo")
+ fmt.debug_set()
.entry(&true)
.entry(&format_args!("{}/{}", 10i32, 20i32))
.finish()
impl fmt::Debug for Bar {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.debug_set("Bar")
+ fmt.debug_set()
.entry(&Foo)
.entry(&"world")
.finish()
}
}
- assert_eq!("Bar { Foo { true, 10/20 }, \"world\" }",
+ assert_eq!("{{true, 10/20}, \"world\"}",
format!("{:?}", Bar));
assert_eq!(
-"Bar {
- Foo {
+"{
+ {
true,
10/20
},
format!("{:#?}", Bar));
}
}
+
+mod debug_list {
+ use std::fmt;
+
+ #[test]
+ fn test_empty() {
+ struct Foo;
+
+ impl fmt::Debug for Foo {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_list().finish()
+ }
+ }
+
+ assert_eq!("[]", format!("{:?}", Foo));
+ assert_eq!("[]", format!("{:#?}", Foo));
+ }
+
+ #[test]
+ fn test_single() {
+ struct Foo;
+
+ impl fmt::Debug for Foo {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_list()
+ .entry(&true)
+ .finish()
+ }
+ }
+
+ assert_eq!("[true]", format!("{:?}", Foo));
+ assert_eq!(
+"[
+ true
+]",
+ format!("{:#?}", Foo));
+ }
+
+ #[test]
+ fn test_multiple() {
+ struct Foo;
+
+ impl fmt::Debug for Foo {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_list()
+ .entry(&true)
+ .entry(&format_args!("{}/{}", 10i32, 20i32))
+ .finish()
+ }
+ }
+
+ assert_eq!("[true, 10/20]", format!("{:?}", Foo));
+ assert_eq!(
+"[
+ true,
+ 10/20
+]",
+ format!("{:#?}", Foo));
+ }
+
+ #[test]
+ fn test_nested() {
+ struct Foo;
+
+ impl fmt::Debug for Foo {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_list()
+ .entry(&true)
+ .entry(&format_args!("{}/{}", 10i32, 20i32))
+ .finish()
+ }
+ }
+
+ struct Bar;
+
+ impl fmt::Debug for Bar {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ fmt.debug_list()
+ .entry(&Foo)
+ .entry(&"world")
+ .finish()
+ }
+ }
+
+ assert_eq!("[[true, 10/20], \"world\"]",
+ format!("{:?}", Bar));
+ assert_eq!(
+"[
+ [
+ true,
+ 10/20
+ ],
+ \"world\"
+]",
+ format!("{:#?}", Bar));
+ }
+}
#[test]
fn test_lt() {
- let empty: [int; 0] = [];
+ let empty: [isize; 0] = [];
let xs = [1,2,3];
let ys = [1,2,0];
#[test]
fn test_counter_from_iter() {
let it = count(0, 5).take(10);
- let xs: Vec<int> = FromIterator::from_iter(it);
+ let xs: Vec<isize> = FromIterator::from_iter(it);
assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
}
fn test_filter_map() {
let it = count(0, 1).take(10)
.filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None });
- assert_eq!(it.collect::<Vec<uint>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
+ assert_eq!(it.collect::<Vec<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]);
}
#[test]
#[test]
fn test_iterator_scan() {
// test the type inference
- fn add(old: &mut int, new: &uint) -> Option<f64> {
- *old += *new as int;
+ fn add(old: &mut isize, new: &usize) -> Option<f64> {
+ *old += *new as isize;
Some(*old as f64)
}
let xs = [0, 1, 2, 3, 4];
let ys = xs.iter()
.cloned()
.inspect(|_| n += 1)
- .collect::<Vec<uint>>();
+ .collect::<Vec<usize>>();
assert_eq!(n, xs.len());
assert_eq!(&xs[..], &ys[..]);
#[test]
fn test_unfoldr() {
- fn count(st: &mut uint) -> Option<uint> {
+ fn count(st: &mut usize) -> Option<usize> {
if *st < 10 {
let ret = Some(*st);
*st += 1;
#[test]
fn test_collect() {
let a = vec![1, 2, 3, 4, 5];
- let b: Vec<int> = a.iter().cloned().collect();
+ let b: Vec<isize> = a.iter().cloned().collect();
assert!(a == b);
}
#[test]
fn test_all() {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
- let v: Box<[int]> = Box::new([1, 2, 3, 4, 5]);
+ let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
assert!(v.iter().all(|&x| x < 10));
assert!(!v.iter().all(|&x| x % 2 == 0));
assert!(!v.iter().all(|&x| x > 100));
#[test]
fn test_any() {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
- let v: Box<[int]> = Box::new([1, 2, 3, 4, 5]);
+ let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]);
assert!(v.iter().any(|&x| x < 10));
assert!(v.iter().any(|&x| x % 2 == 0));
assert!(!v.iter().any(|&x| x > 100));
#[test]
fn test_find() {
- let v: &[int] = &[1, 3, 9, 27, 103, 14, 11];
+ let v: &[isize] = &[1, 3, 9, 27, 103, 14, 11];
assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14);
assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3);
assert!(v.iter().find(|&&x| x % 12 == 0).is_none());
#[test]
fn test_max_by() {
- let xs: &[int] = &[-3, 0, 1, 5, -10];
+ let xs: &[isize] = &[-3, 0, 1, 5, -10];
assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
}
#[test]
fn test_min_by() {
- let xs: &[int] = &[-3, 0, 1, 5, -10];
+ let xs: &[isize] = &[-3, 0, 1, 5, -10];
assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
}
let mut it = xs.iter();
it.next();
it.next();
- assert!(it.rev().cloned().collect::<Vec<int>>() ==
+ assert!(it.rev().cloned().collect::<Vec<isize>>() ==
vec![16, 14, 12, 10, 8, 6]);
}
#[test]
fn test_rposition() {
- fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
- fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
+ fn f(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'b' }
+ fn g(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'd' }
let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
assert_eq!(v.iter().rposition(f), Some(3));
#[cfg(test)]
-fn check_randacc_iter<A, T>(a: T, len: uint) where
+fn check_randacc_iter<A, T>(a: T, len: usize) where
A: PartialEq,
T: Clone + RandomAccessIterator + Iterator<Item=A>,
{
#[test]
fn test_random_access_take() {
let xs = [1, 2, 3, 4, 5];
- let empty: &[int] = &[];
+ let empty: &[isize] = &[];
check_randacc_iter(xs.iter().take(3), 3);
check_randacc_iter(xs.iter().take(20), xs.len());
check_randacc_iter(xs.iter().take(0), 0);
#[test]
fn test_random_access_skip() {
let xs = [1, 2, 3, 4, 5];
- let empty: &[int] = &[];
+ let empty: &[isize] = &[];
check_randacc_iter(xs.iter().skip(2), xs.len() - 2);
check_randacc_iter(empty.iter().skip(2), 0);
}
#[test]
fn test_random_access_cycle() {
let xs = [1, 2, 3, 4, 5];
- let empty: &[int] = &[];
+ let empty: &[isize] = &[];
check_randacc_iter(xs.iter().cycle().take(27), 27);
check_randacc_iter(empty.iter().cycle(), 0);
}
assert_eq!((200..200).rev().count(), 0);
assert_eq!((0..100).size_hint(), (100, Some(100)));
- // this test is only meaningful when sizeof uint < sizeof u64
+ // this test is only meaningful when sizeof usize < sizeof u64
assert_eq!((usize::MAX - 1..usize::MAX).size_hint(), (1, Some(1)));
assert_eq!((-10..-1).size_hint(), (9, Some(9)));
assert_eq!((-1..-10).size_hint(), (0, Some(0)));
#[test]
fn test_range_inclusive() {
- assert!(range_inclusive(0, 5).collect::<Vec<int>>() ==
+ assert!(range_inclusive(0, 5).collect::<Vec<isize>>() ==
vec![0, 1, 2, 3, 4, 5]);
- assert!(range_inclusive(0, 5).rev().collect::<Vec<int>>() ==
+ assert!(range_inclusive(0, 5).rev().collect::<Vec<isize>>() ==
vec![5, 4, 3, 2, 1, 0]);
assert_eq!(range_inclusive(200, -5).count(), 0);
assert_eq!(range_inclusive(200, -5).rev().count(), 0);
- assert_eq!(range_inclusive(200, 200).collect::<Vec<int>>(), [200]);
- assert_eq!(range_inclusive(200, 200).rev().collect::<Vec<int>>(), [200]);
+ assert_eq!(range_inclusive(200, 200).collect::<Vec<isize>>(), [200]);
+ assert_eq!(range_inclusive(200, 200).rev().collect::<Vec<isize>>(), [200]);
}
#[test]
fn test_range_step() {
- assert_eq!((0..20).step_by(5).collect::<Vec<int>>(), [0, 5, 10, 15]);
- assert_eq!((20..0).step_by(-5).collect::<Vec<int>>(), [20, 15, 10, 5]);
- assert_eq!((20..0).step_by(-6).collect::<Vec<int>>(), [20, 14, 8, 2]);
+ assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]);
+ assert_eq!((20..0).step_by(-5).collect::<Vec<isize>>(), [20, 15, 10, 5]);
+ assert_eq!((20..0).step_by(-6).collect::<Vec<isize>>(), [20, 14, 8, 2]);
assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]);
- assert_eq!((200..-5).step_by(1).collect::<Vec<int>>(), []);
- assert_eq!((200..200).step_by(1).collect::<Vec<int>>(), []);
+ assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
+ assert_eq!((200..200).step_by(1).collect::<Vec<isize>>(), []);
}
#[test]
fn test_range_step_inclusive() {
- assert_eq!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15, 20]);
- assert_eq!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5, 0]);
- assert_eq!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]);
+ assert_eq!(range_step_inclusive(0, 20, 5).collect::<Vec<isize>>(), [0, 5, 10, 15, 20]);
+ assert_eq!(range_step_inclusive(20, 0, -5).collect::<Vec<isize>>(), [20, 15, 10, 5, 0]);
+ assert_eq!(range_step_inclusive(20, 0, -6).collect::<Vec<isize>>(), [20, 14, 8, 2]);
assert_eq!(range_step_inclusive(200, 255, 50).collect::<Vec<u8>>(), [200, 250]);
- assert_eq!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>(), []);
- assert_eq!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>(), [200]);
+ assert_eq!(range_step_inclusive(200, -5, 1).collect::<Vec<isize>>(), []);
+ assert_eq!(range_step_inclusive(200, 200, 1).collect::<Vec<isize>>(), [200]);
}
#[test]
#[test]
fn test_min_max() {
- let v: [int; 0] = [];
+ let v: [isize; 0] = [];
assert_eq!(v.iter().min_max(), NoElements);
let v = [1];
#[test]
fn test_min_max_result() {
- let r: MinMaxResult<int> = NoElements;
+ let r: MinMaxResult<isize> = NoElements;
assert_eq!(r.into_option(), None);
let r = OneElement(1);
#[bench]
fn bench_rposition(b: &mut Bencher) {
- let it: Vec<uint> = (0..300).collect();
+ let it: Vec<usize> = (0..300).collect();
b.iter(|| {
it.iter().rposition(|&x| x <= 150);
});
#![feature(debug_builders)]
#![feature(unique)]
#![feature(step_by)]
+#![feature(slice_patterns)]
#![allow(deprecated)] // rand
extern crate core;
#[test]
#[cfg(target_pointer_width = "32")]
fn size_of_32() {
- assert_eq!(size_of::<uint>(), 4);
- assert_eq!(size_of::<*const uint>(), 4);
+ assert_eq!(size_of::<usize>(), 4);
+ assert_eq!(size_of::<*const usize>(), 4);
}
#[test]
#[cfg(target_pointer_width = "64")]
fn size_of_64() {
- assert_eq!(size_of::<uint>(), 8);
- assert_eq!(size_of::<*const uint>(), 8);
+ assert_eq!(size_of::<usize>(), 8);
+ assert_eq!(size_of::<*const usize>(), 8);
}
#[test]
#[test]
#[cfg(target_pointer_width = "32")]
fn align_of_32() {
- assert_eq!(align_of::<uint>(), 4);
- assert_eq!(align_of::<*const uint>(), 4);
+ assert_eq!(align_of::<usize>(), 4);
+ assert_eq!(align_of::<*const usize>(), 4);
}
#[test]
#[cfg(target_pointer_width = "64")]
fn align_of_64() {
- assert_eq!(align_of::<uint>(), 8);
- assert_eq!(align_of::<*const uint>(), 8);
+ assert_eq!(align_of::<usize>(), 8);
+ assert_eq!(align_of::<*const usize>(), 8);
}
#[test]
#[test]
fn test_transmute() {
trait Foo { fn dummy(&self) { } }
- impl Foo for int {}
+ impl Foo for isize {}
let a = box 100isize as Box<Foo>;
unsafe {
let x: ::core::raw::TraitObject = transmute(a);
- assert!(*(x.data as *const int) == 100);
+ assert!(*(x.data as *const isize) == 100);
let _x: Box<Foo> = transmute(x);
}
// Static/dynamic method dispatch
struct Struct {
- field: int
+ field: isize
}
trait Trait {
- fn method(&self) -> int;
+ fn method(&self) -> isize;
}
impl Trait for Struct {
- fn method(&self) -> int {
+ fn method(&self) -> isize {
self.field
}
}
#[test]
fn test_match_option_empty_vec() {
- let a: Option<Vec<int>> = Some(vec![]);
+ let a: Option<Vec<isize>> = Some(vec![]);
match a {
None => panic!("unexpected None while matching on Some(vec![])"),
_ => {}
// Overhead of dtors
struct HasDtor {
- _x: int
+ _x: isize
}
impl Drop for HasDtor {
fn test_get_ptr() {
unsafe {
let x: Box<_> = box 0;
- let addr_x: *const int = mem::transmute(&*x);
+ let addr_x: *const isize = mem::transmute(&*x);
let opt = Some(x);
let y = opt.unwrap();
- let addr_y: *const int = mem::transmute(&*y);
+ let addr_y: *const isize = mem::transmute(&*y);
assert_eq!(addr_x, addr_y);
}
}
use core::cell::RefCell;
struct R {
- i: Rc<RefCell<int>>,
+ i: Rc<RefCell<isize>>,
}
#[unsafe_destructor]
}
}
- fn r(i: Rc<RefCell<int>>) -> R {
+ fn r(i: Rc<RefCell<isize>>) -> R {
R {
i: i
}
#[test]
fn test_and() {
- let x: Option<int> = Some(1);
+ let x: Option<isize> = Some(1);
assert_eq!(x.and(Some(2)), Some(2));
- assert_eq!(x.and(None::<int>), None);
+ assert_eq!(x.and(None::<isize>), None);
- let x: Option<int> = None;
+ let x: Option<isize> = None;
assert_eq!(x.and(Some(2)), None);
- assert_eq!(x.and(None::<int>), None);
+ assert_eq!(x.and(None::<isize>), None);
}
#[test]
fn test_and_then() {
- let x: Option<int> = Some(1);
+ let x: Option<isize> = Some(1);
assert_eq!(x.and_then(|x| Some(x + 1)), Some(2));
- assert_eq!(x.and_then(|_| None::<int>), None);
+ assert_eq!(x.and_then(|_| None::<isize>), None);
- let x: Option<int> = None;
+ let x: Option<isize> = None;
assert_eq!(x.and_then(|x| Some(x + 1)), None);
- assert_eq!(x.and_then(|_| None::<int>), None);
+ assert_eq!(x.and_then(|_| None::<isize>), None);
}
#[test]
fn test_or() {
- let x: Option<int> = Some(1);
+ let x: Option<isize> = Some(1);
assert_eq!(x.or(Some(2)), Some(1));
assert_eq!(x.or(None), Some(1));
- let x: Option<int> = None;
+ let x: Option<isize> = None;
assert_eq!(x.or(Some(2)), Some(2));
assert_eq!(x.or(None), None);
}
#[test]
fn test_or_else() {
- let x: Option<int> = Some(1);
+ let x: Option<isize> = Some(1);
assert_eq!(x.or_else(|| Some(2)), Some(1));
assert_eq!(x.or_else(|| None), Some(1));
- let x: Option<int> = None;
+ let x: Option<isize> = None;
assert_eq!(x.or_else(|| Some(2)), Some(2));
assert_eq!(x.or_else(|| None), None);
}
#[test]
#[should_panic]
fn test_unwrap_panic1() {
- let x: Option<int> = None;
+ let x: Option<isize> = None;
x.unwrap();
}
#[test]
fn test_unwrap_or() {
- let x: Option<int> = Some(1);
+ let x: Option<isize> = Some(1);
assert_eq!(x.unwrap_or(2), 1);
- let x: Option<int> = None;
+ let x: Option<isize> = None;
assert_eq!(x.unwrap_or(2), 2);
}
#[test]
fn test_unwrap_or_else() {
- let x: Option<int> = Some(1);
+ let x: Option<isize> = Some(1);
assert_eq!(x.unwrap_or_else(|| 2), 1);
- let x: Option<int> = None;
+ let x: Option<isize> = None;
assert_eq!(x.unwrap_or_else(|| 2), 2);
}
/* FIXME(#20575)
#[test]
fn test_collect() {
- let v: Option<Vec<int>> = (0..0).map(|_| Some(0)).collect();
+ let v: Option<Vec<isize>> = (0..0).map(|_| Some(0)).collect();
assert!(v == Some(vec![]));
- let v: Option<Vec<int>> = (0..3).map(|x| Some(x)).collect();
+ let v: Option<Vec<isize>> = (0..3).map(|x| Some(x)).collect();
assert!(v == Some(vec![0, 1, 2]));
- let v: Option<Vec<int>> = (0..3).map(|x| {
+ let v: Option<Vec<isize>> = (0..3).map(|x| {
if x > 1 { None } else { Some(x) }
}).collect();
assert!(v == None);
assert_eq!(opt_none.clone(), None);
assert_eq!(opt_none.cloned(), None);
- // Mutable refs work
- assert_eq!(opt_mut_ref.cloned(), Some(2u32));
-
// Immutable ref works
assert_eq!(opt_ref.clone(), Some(&val1));
assert_eq!(opt_ref.cloned(), Some(1u32));
fn test() {
unsafe {
struct Pair {
- fst: int,
- snd: int
+ fst: isize,
+ snd: isize
};
let mut p = Pair {fst: 10, snd: 20};
let pptr: *mut Pair = &mut p;
- let iptr: *mut int = mem::transmute(pptr);
+ let iptr: *mut isize = mem::transmute(pptr);
assert_eq!(*iptr, 10);
*iptr = 30;
assert_eq!(*iptr, 30);
let v0 = vec![32000u16, 32001u16, 32002u16];
let mut v1 = vec![0u16, 0u16, 0u16];
- copy(v1.as_mut_ptr().offset(1),
- v0.as_ptr().offset(1), 1);
+ copy(v0.as_ptr().offset(1), v1.as_mut_ptr().offset(1), 1);
assert!((v1[0] == 0u16 &&
v1[1] == 32001u16 &&
v1[2] == 0u16));
- copy(v1.as_mut_ptr(),
- v0.as_ptr().offset(2), 1);
+ copy(v0.as_ptr().offset(2), v1.as_mut_ptr(), 1);
assert!((v1[0] == 32002u16 &&
v1[1] == 32001u16 &&
v1[2] == 0u16));
- copy(v1.as_mut_ptr().offset(2),
- v0.as_ptr(), 1);
+ copy(v0.as_ptr(), v1.as_mut_ptr().offset(2), 1);
assert!((v1[0] == 32002u16 &&
v1[1] == 32001u16 &&
v1[2] == 32000u16));
#[test]
fn test_is_null() {
- let p: *const int = null();
+ let p: *const isize = null();
assert!(p.is_null());
let q = unsafe { p.offset(1) };
assert!(!q.is_null());
- let mp: *mut int = null_mut();
+ let mp: *mut isize = null_mut();
assert!(mp.is_null());
let mq = unsafe { mp.offset(1) };
#[test]
fn test_as_ref() {
unsafe {
- let p: *const int = null();
+ let p: *const isize = null();
assert_eq!(p.as_ref(), None);
- let q: *const int = &2;
+ let q: *const isize = &2;
assert_eq!(q.as_ref().unwrap(), &2);
- let p: *mut int = null_mut();
+ let p: *mut isize = null_mut();
assert_eq!(p.as_ref(), None);
- let q: *mut int = &mut 2;
+ let q: *mut isize = &mut 2;
assert_eq!(q.as_ref().unwrap(), &2);
// Lifetime inference
let u = 2isize;
{
- let p = &u as *const int;
+ let p = &u as *const isize;
assert_eq!(p.as_ref().unwrap(), &2);
}
}
#[test]
fn test_as_mut() {
unsafe {
- let p: *mut int = null_mut();
+ let p: *mut isize = null_mut();
assert!(p.as_mut() == None);
- let q: *mut int = &mut 2;
+ let q: *mut isize = &mut 2;
assert!(q.as_mut().unwrap() == &mut 2);
// Lifetime inference
let mut u = 2isize;
{
- let p = &mut u as *mut int;
+ let p = &mut u as *mut isize;
assert!(p.as_mut().unwrap() == &mut 2);
}
}
let ptr = xs.as_ptr();
while idx >= 0 {
- assert_eq!(*(ptr.offset(idx as int)), idx as int);
+ assert_eq!(*(ptr.offset(idx as isize)), idx as isize);
idx = idx - 1;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn op1() -> Result<int, &'static str> { Ok(666) }
-pub fn op2() -> Result<int, &'static str> { Err("sadface") }
+pub fn op1() -> Result<isize, &'static str> { Ok(666) }
+pub fn op2() -> Result<isize, &'static str> { Err("sadface") }
#[test]
pub fn test_and() {
#[test]
pub fn test_and_then() {
- assert_eq!(op1().and_then(|i| Ok::<int, &'static str>(i + 1)).unwrap(), 667);
- assert_eq!(op1().and_then(|_| Err::<int, &'static str>("bad")).unwrap_err(),
+ assert_eq!(op1().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap(), 667);
+ assert_eq!(op1().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
"bad");
- assert_eq!(op2().and_then(|i| Ok::<int, &'static str>(i + 1)).unwrap_err(),
+ assert_eq!(op2().and_then(|i| Ok::<isize, &'static str>(i + 1)).unwrap_err(),
"sadface");
- assert_eq!(op2().and_then(|_| Err::<int, &'static str>("bad")).unwrap_err(),
+ assert_eq!(op2().and_then(|_| Err::<isize, &'static str>("bad")).unwrap_err(),
"sadface");
}
#[test]
pub fn test_or_else() {
- assert_eq!(op1().or_else(|_| Ok::<int, &'static str>(667)).unwrap(), 666);
- assert_eq!(op1().or_else(|e| Err::<int, &'static str>(e)).unwrap(), 666);
+ assert_eq!(op1().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 666);
+ assert_eq!(op1().or_else(|e| Err::<isize, &'static str>(e)).unwrap(), 666);
- assert_eq!(op2().or_else(|_| Ok::<int, &'static str>(667)).unwrap(), 667);
- assert_eq!(op2().or_else(|e| Err::<int, &'static str>(e)).unwrap_err(),
+ assert_eq!(op2().or_else(|_| Ok::<isize, &'static str>(667)).unwrap(), 667);
+ assert_eq!(op2().or_else(|e| Err::<isize, &'static str>(e)).unwrap_err(),
"sadface");
}
#[test]
pub fn test_impl_map() {
- assert!(Ok::<int, int>(1).map(|x| x + 1) == Ok(2));
- assert!(Err::<int, int>(1).map(|x| x + 1) == Err(1));
+ assert!(Ok::<isize, isize>(1).map(|x| x + 1) == Ok(2));
+ assert!(Err::<isize, isize>(1).map(|x| x + 1) == Err(1));
}
#[test]
pub fn test_impl_map_err() {
- assert!(Ok::<int, int>(1).map_err(|x| x + 1) == Ok(1));
- assert!(Err::<int, int>(1).map_err(|x| x + 1) == Err(2));
+ assert!(Ok::<isize, isize>(1).map_err(|x| x + 1) == Ok(1));
+ assert!(Err::<isize, isize>(1).map_err(|x| x + 1) == Err(2));
}
/* FIXME(#20575)
#[test]
fn test_collect() {
- let v: Result<Vec<int>, ()> = (0..0).map(|_| Ok::<int, ()>(0)).collect();
+ let v: Result<Vec<isize>, ()> = (0..0).map(|_| Ok::<isize, ()>(0)).collect();
assert!(v == Ok(vec![]));
- let v: Result<Vec<int>, ()> = (0..3).map(|x| Ok::<int, ()>(x)).collect();
+ let v: Result<Vec<isize>, ()> = (0..3).map(|x| Ok::<isize, ()>(x)).collect();
assert!(v == Ok(vec![0, 1, 2]));
- let v: Result<Vec<int>, int> = (0..3).map(|x| {
+ let v: Result<Vec<isize>, isize> = (0..3).map(|x| {
if x > 1 { Err(x) } else { Ok(x) }
}).collect();
assert!(v == Err(2));
// test that it does not take more elements than it needs
- let mut functions: [Box<Fn() -> Result<(), int>>; 3] =
+ let mut functions: [Box<Fn() -> Result<(), isize>>; 3] =
[box || Ok(()), box || Err(1), box || panic!()];
- let v: Result<Vec<()>, int> = functions.iter_mut().map(|f| (*f)()).collect();
+ let v: Result<Vec<()>, isize> = functions.iter_mut().map(|f| (*f)()).collect();
assert!(v == Err(1));
}
*/
#[test]
pub fn test_fmt_default() {
- let ok: Result<int, &'static str> = Ok(100);
- let err: Result<int, &'static str> = Err("Err");
+ let ok: Result<isize, &'static str> = Ok(100);
+ let err: Result<isize, &'static str> = Err("Err");
let s = format!("{:?}", ok);
assert_eq!(s, "Ok(100)");
#[test]
pub fn test_unwrap_or() {
- let ok: Result<int, &'static str> = Ok(100);
- let ok_err: Result<int, &'static str> = Err("Err");
+ let ok: Result<isize, &'static str> = Ok(100);
+ let ok_err: Result<isize, &'static str> = Err("Err");
assert_eq!(ok.unwrap_or(50), 100);
assert_eq!(ok_err.unwrap_or(50), 50);
#[test]
pub fn test_unwrap_or_else() {
- fn handler(msg: &'static str) -> int {
+ fn handler(msg: &'static str) -> isize {
if msg == "I got this." {
50
} else {
}
}
- let ok: Result<int, &'static str> = Ok(100);
- let ok_err: Result<int, &'static str> = Err("I got this.");
+ let ok: Result<isize, &'static str> = Ok(100);
+ let ok_err: Result<isize, &'static str> = Err("I got this.");
assert_eq!(ok.unwrap_or_else(handler), 100);
assert_eq!(ok_err.unwrap_or_else(handler), 50);
#[test]
#[should_panic]
pub fn test_unwrap_or_else_panic() {
- fn handler(msg: &'static str) -> int {
+ fn handler(msg: &'static str) -> isize {
if msg == "I got this." {
50
} else {
}
}
- let bad_err: Result<int, &'static str> = Err("Unrecoverable mess.");
- let _ : int = bad_err.unwrap_or_else(handler);
+ let bad_err: Result<isize, &'static str> = Err("Unrecoverable mess.");
+ let _ : isize = bad_err.unwrap_or_else(handler);
}
html_playground_url = "http://play.rust-lang.org/")]
#![deny(missing_docs)]
-#![feature(int_uint)]
#![feature(staged_api)]
#![feature(str_words)]
#![feature(str_char)]
}
/// Returns the number of times an option was matched.
- pub fn opt_count(&self, nm: &str) -> uint {
+ pub fn opt_count(&self, nm: &str) -> usize {
self.opt_vals(nm).len()
}
arg.len() > 1 && arg.as_bytes()[0] == b'-'
}
-fn find_opt(opts: &[Opt], nm: Name) -> Option<uint> {
+fn find_opt(opts: &[Opt], nm: Name) -> Option<usize> {
// Search main options.
let pos = opts.iter().position(|opt| opt.name == nm);
if pos.is_some() {
let opts: Vec<Opt> = optgrps.iter().map(|x| x.long_to_short()).collect();
let n_opts = opts.len();
- fn f(_x: uint) -> Vec<Optval> { return Vec::new(); }
+ fn f(_x: usize) -> Vec<Optval> { return Vec::new(); }
let mut vals: Vec<_> = (0..n_opts).map(f).collect();
let mut free: Vec<String> = Vec::new();
///
/// Panics during iteration if the string contains a non-whitespace
/// sequence longer than the limit.
-fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where
+fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
F: FnMut(&str) -> bool
{
// Just for fun, let's write this as a state machine:
lim = fake_i;
}
- let mut machine = |cont: &mut bool, (i, c): (uint, char)| -> bool {
+ let mut machine = |cont: &mut bool, (i, c): (usize, char)| -> bool {
let whitespace = if c.is_whitespace() { Ws } else { Cr };
let limit = if (i - slice_start + 1) <= lim { UnderLim } else { OverLim };
#[test]
fn test_split_within() {
- fn t(s: &str, i: uint, u: &[String]) {
+ fn t(s: &str, i: usize, u: &[String]) {
let mut v = Vec::new();
each_split_within(s, i, |s| { v.push(s.to_string()); true });
assert!(v.iter().zip(u.iter()).all(|(a,b)| a == b));
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(int_uint)]
#![feature(collections)]
#![feature(into_cow)]
#![allow(bad_style, raw_pointer_derive)]
#![cfg_attr(target_os = "nacl", allow(unused_imports))]
-#[cfg(feature = "cargo-build")] extern crate "std" as core;
+#[cfg(feature = "cargo-build")] extern crate std as core;
#[cfg(not(feature = "cargo-build"))] extern crate core;
#[cfg(test)] extern crate std;
#[derive(Copy)] pub struct sockaddr_storage {
pub ss_family: sa_family_t,
pub __ss_align: isize,
- pub __ss_pad2: [u8; 128 - 2 * (::core::isize::BYTES as usize)],
+ #[cfg(target_pointer_width = "32")]
+ pub __ss_pad2: [u8; 128 - 2 * 4],
+ #[cfg(target_pointer_width = "64")]
+ pub __ss_pad2: [u8; 128 - 2 * 8],
}
#[repr(C)]
#[derive(Copy)] pub struct sockaddr_in {
#![feature(alloc)]
#![feature(staged_api)]
#![feature(box_syntax)]
-#![feature(int_uint)]
#![feature(core)]
#![feature(std_misc)]
impl fmt::Display for LogLevel {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let LogLevel(level) = *self;
- match LOG_LEVEL_NAMES.get(level as uint - 1) {
+ match LOG_LEVEL_NAMES.get(level as usize - 1) {
Some(ref name) => fmt::Display::fmt(name, fmt),
None => fmt::Display::fmt(&level, fmt)
}
// is one.
unsafe {
let _g = LOCK.lock();
- match FILTER as uint {
+ match FILTER as usize {
0 => {}
1 => panic!("cannot log after main thread has exited"),
n => {
let _g = LOCK.lock();
unsafe {
- assert!(DIRECTIVES as uint != 0);
- assert!(DIRECTIVES as uint != 1,
+ assert!(DIRECTIVES as usize != 0);
+ assert!(DIRECTIVES as usize != 1,
"cannot log after the main thread has exited");
enabled(level, module, (*DIRECTIVES).iter())
use core::num::wrapping::WrappingOps;
use {Rng, SeedableRng, Rand};
-const KEY_WORDS : uint = 8; // 8 words for the 256-bit key
-const STATE_WORDS : uint = 16;
-const CHACHA_ROUNDS: uint = 20; // Cryptographically secure from 8 upwards as of this writing
+const KEY_WORDS : usize = 8; // 8 words for the 256-bit key
+const STATE_WORDS : usize = 16;
+const CHACHA_ROUNDS: usize = 20; // Cryptographically secure from 8 upwards as of this writing
/// A random number generator that uses the ChaCha20 algorithm [1].
///
pub struct ChaChaRng {
buffer: [u32; STATE_WORDS], // Internal buffer of output
state: [u32; STATE_WORDS], // Initial state
- index: uint, // Index into state
+ index: usize, // Index into state
}
static EMPTY: ChaChaRng = ChaChaRng {
/// A value with a particular weight for use with `WeightedChoice`.
pub struct Weighted<T> {
/// The numerical weight of this item
- pub weight: uint,
+ pub weight: usize,
/// The actual item which is being weighted
pub item: T,
}
///
/// The `Clone` restriction is a limitation of the `Sample` and
/// `IndependentSample` traits. Note that `&T` is (cheaply) `Clone` for
-/// all `T`, as is `uint`, so one can store references or indices into
+/// all `T`, as is `usize`, so one can store references or indices into
/// another vector.
///
/// # Examples
/// let mut items = vec!(Weighted { weight: 2, item: 'a' },
/// Weighted { weight: 4, item: 'b' },
/// Weighted { weight: 1, item: 'c' });
-/// let wc = WeightedChoice::new(items.as_mut_slice());
+/// let wc = WeightedChoice::new(&mut items[..]);
/// let mut rng = rand::thread_rng();
/// for _ in 0..16 {
/// // on average prints 'a' 4 times, 'b' 8 and 'c' twice.
/// ```
pub struct WeightedChoice<'a, T:'a> {
items: &'a mut [Weighted<T>],
- weight_range: Range<uint>
+ weight_range: Range<usize>
}
impl<'a, T: Clone> WeightedChoice<'a, T> {
/// Panics if:
/// - `v` is empty
/// - the total weight is 0
- /// - the total weight is larger than a `uint` can contain.
+ /// - the total weight is larger than a `usize` can contain.
pub fn new(items: &'a mut [Weighted<T>]) -> WeightedChoice<'a, T> {
// strictly speaking, this is subsumed by the total weight == 0 case
assert!(!items.is_empty(), "WeightedChoice::new called with no items");
running_total = match running_total.checked_add(item.weight) {
Some(n) => n,
None => panic!("WeightedChoice::new called with a total weight \
- larger than a uint can contain")
+ larger than a usize can contain")
};
item.weight = running_total;
// this may be slower than it would be otherwise.)
// FIXME: investigate/optimise for the above.
let bits: u64 = rng.gen();
- let i = (bits & 0xff) as uint;
+ let i = (bits & 0xff) as usize;
let f = (bits >> 11) as f64 / SCALE;
// u is either U(-1, 1) or U(0, 1) depending on if this is a
return zero_case(rng, u);
}
// algebraically equivalent to f1 + DRanU()*(f0 - f1) < 1
- if f_tab[i + 1] + (f_tab[i] - f_tab[i + 1]) * rng.gen() < pdf(x) {
+ if f_tab[i + 1] + (f_tab[i] - f_tab[i + 1]) * rng.gen::<f64>() < pdf(x) {
return x;
}
}
use super::{RandSample, WeightedChoice, Weighted, Sample, IndependentSample};
#[derive(PartialEq, Debug)]
- struct ConstRand(uint);
+ struct ConstRand(usize);
impl Rand for ConstRand {
fn rand<R: Rng>(_: &mut R) -> ConstRand {
ConstRand(0)
#[test] #[should_panic]
fn test_weighted_choice_no_items() {
- WeightedChoice::<int>::new(&mut []);
+ WeightedChoice::<isize>::new(&mut []);
}
#[test] #[should_panic]
fn test_weighted_choice_zero_weight() {
}
#[test] #[should_panic]
fn test_weighted_choice_weight_overflows() {
- let x = (-1) as uint / 2; // x + x + 2 is the overflow
+ let x = (-1) as usize / 2; // x + x + 2 is the overflow
WeightedChoice::new(&mut [Weighted { weight: x, item: 0 },
Weighted { weight: 1, item: 1 },
Weighted { weight: x, item: 2 },
//! Generating numbers between two others.
-#![allow(trivial_numeric_casts)]
-
// this is surprisingly complicated to be both generic & correct
-use core::prelude::{PartialOrd};
+use core::prelude::PartialOrd;
use core::num::Int;
use core::num::wrapping::WrappingOps;
integer_impl! { i16, u16 }
integer_impl! { i32, u32 }
integer_impl! { i64, u64 }
-integer_impl! { int, uint }
+integer_impl! { isize, usize }
integer_impl! { u8, u8 }
integer_impl! { u16, u16 }
integer_impl! { u32, u32 }
integer_impl! { u64, u64 }
-integer_impl! { uint, uint }
+integer_impl! { usize, usize }
macro_rules! float_impl {
($ty:ty) => {
}
}
fn sample_range<R: Rng>(r: &Range<$ty>, rng: &mut R) -> $ty {
- r.low + r.range * rng.gen()
+ r.low + r.range * rng.gen::<$ty>()
}
}
}
)*
}}
}
- t!(i8, i16, i32, i64, int,
- u8, u16, u32, u64, uint)
+ t!(i8, i16, i32, i64, isize,
+ u8, u16, u32, u64, usize)
}
#[test]
use core::prelude::*;
use core::slice;
-use core::iter::{range_step, repeat};
-use core::num::wrapping::Wrapping as w;
+use core::iter::repeat;
+use core::num::Wrapping as w;
use {Rng, SeedableRng, Rand};
if use_rsl {
macro_rules! memloop {
($arr:expr) => {{
- for i in range_step(0, RAND_SIZE_USIZE, 8) {
+ for i in (0..RAND_SIZE_USIZE).step_by(8) {
a=a+$arr[i ]; b=b+$arr[i+1];
c=c+$arr[i+2]; d=d+$arr[i+3];
e=e+$arr[i+4]; f=f+$arr[i+5];
memloop!(self.rsl);
memloop!(self.mem);
} else {
- for i in range_step(0, RAND_SIZE_USIZE, 8) {
+ for i in (0..RAND_SIZE_USIZE).step_by(8) {
mix!();
self.mem[i ]=a; self.mem[i+1]=b;
self.mem[i+2]=c; self.mem[i+3]=d;
const MIDPOINT: usize = RAND_SIZE_USIZE / 2;
macro_rules! ind {
- ($x:expr) => ( self.mem[($x >> 2).0 as usize & (RAND_SIZE_USIZE - 1)] )
+ ($x:expr) => (self.mem[($x >> 2).0 as usize & (RAND_SIZE_USIZE - 1)] )
}
let r = [(0, MIDPOINT), (MIDPOINT, 0)];
}}
}
- for i in range_step(0, MIDPOINT, 4) {
+ for i in (0..MIDPOINT).step_by(4) {
rngstepp!(i + 0, 13);
rngstepn!(i + 1, 6);
rngstepp!(i + 2, 2);
#[inline]
fn next_u64(&mut self) -> u64 {
- #![allow(trivial_numeric_casts)]
if self.cnt == 0 {
// make some more numbers
self.isaac64();
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/",
html_playground_url = "http://play.rust-lang.org/")]
-#![feature(int_uint)]
#![feature(no_std)]
#![no_std]
#![unstable(feature = "rand")]
#![feature(staged_api)]
#![staged_api]
#![feature(core)]
+#![feature(step_by)]
#![deprecated(reason = "use the crates.io `rand` library instead",
since = "1.0.0-alpha")]
/// See `Closed01` for the closed interval `[0,1]`, and
/// `Open01` for the open interval `(0,1)`.
fn next_f32(&mut self) -> f32 {
- const MANTISSA_BITS: uint = 24;
- const IGNORED_BITS: uint = 8;
+ const MANTISSA_BITS: usize = 24;
+ const IGNORED_BITS: usize = 8;
const SCALE: f32 = (1u64 << MANTISSA_BITS) as f32;
// using any more than `MANTISSA_BITS` bits will
/// See `Closed01` for the closed interval `[0,1]`, and
/// `Open01` for the open interval `(0,1)`.
fn next_f64(&mut self) -> f64 {
- const MANTISSA_BITS: uint = 53;
- const IGNORED_BITS: uint = 11;
+ const MANTISSA_BITS: usize = 53;
+ const IGNORED_BITS: usize = 11;
const SCALE: f64 = (1u64 << MANTISSA_BITS) as f64;
(self.next_u64() >> IGNORED_BITS) as f64 / SCALE
/// use std::rand::{thread_rng, Rng};
///
/// let mut rng = thread_rng();
- /// let x: uint = rng.gen();
+ /// let x: usize = rng.gen();
/// println!("{}", x);
/// println!("{:?}", rng.gen::<(f64, bool)>());
/// ```
/// use std::rand::{thread_rng, Rng};
///
/// let mut rng = thread_rng();
- /// let x = rng.gen_iter::<uint>().take(10).collect::<Vec<uint>>();
+ /// let x = rng.gen_iter::<usize>().take(10).collect::<Vec<usize>>();
/// println!("{:?}", x);
/// println!("{:?}", rng.gen_iter::<(f64, bool)>().take(5)
/// .collect::<Vec<(f64, bool)>>());
/// use std::rand::{thread_rng, Rng};
///
/// let mut rng = thread_rng();
- /// let n: uint = rng.gen_range(0, 10);
+ /// let n: usize = rng.gen_range(0, 10);
/// println!("{}", n);
/// let m: f64 = rng.gen_range(-40.0f64, 1.3e5f64);
/// println!("{}", m);
/// let mut rng = thread_rng();
/// println!("{}", rng.gen_weighted_bool(3));
/// ```
- fn gen_weighted_bool(&mut self, n: uint) -> bool {
+ fn gen_weighted_bool(&mut self, n: usize) -> bool {
n <= 1 || self.gen_range(0, n) == 0
}
/// How many bytes of entropy the underling RNG is allowed to generate
/// before it is reseeded.
-const DEFAULT_GENERATION_THRESHOLD: uint = 32 * 1024;
+const DEFAULT_GENERATION_THRESHOLD: usize = 32 * 1024;
/// A wrapper around any RNG which reseeds the underlying RNG after it
/// has generated a certain number of random bytes.
pub struct ReseedingRng<R, Rsdr> {
rng: R,
- generation_threshold: uint,
- bytes_generated: uint,
+ generation_threshold: usize,
+ bytes_generated: usize,
/// Controls the behaviour when reseeding the RNG.
pub reseeder: Rsdr,
}
/// * `rng`: the random number generator to use.
/// * `generation_threshold`: the number of bytes of entropy at which to reseed the RNG.
/// * `reseeder`: the reseeding object to use.
- pub fn new(rng: R, generation_threshold: uint, reseeder: Rsdr) -> ReseedingRng<R,Rsdr> {
+ pub fn new(rng: R, generation_threshold: usize, reseeder: Rsdr) -> ReseedingRng<R,Rsdr> {
ReseedingRng {
rng: rng,
generation_threshold: generation_threshold,
assert_eq!(string1, string2);
}
- const FILL_BYTES_V_LEN: uint = 13579;
+ const FILL_BYTES_V_LEN: usize = 13579;
#[test]
fn test_rng_fill_bytes() {
let mut v = repeat(0).take(FILL_BYTES_V_LEN).collect::<Vec<_>>();
//! where the tag number is ORed with 0xf000. (E.g. tag 0x123 = `f1 23`)
//!
//! **Lengths** encode the length of the following data.
-//! It is a variable-length unsigned int, and one of the following forms:
+//! It is a variable-length unsigned isize, and one of the following forms:
//!
//! - `80` through `fe` for lengths up to 0x7e;
//! - `40 ff` through `7f ff` for lengths up to 0x3fff;
//! - `Sub32` (`0d`): 4-byte unsigned integer for supplementary information.
//! Those two tags normally occur as the first subdocument of certain tags,
//! namely `Enum`, `Vec` and `Map`, to provide a variant or size information.
-//! They can be used interchangably.
+//! They can be used interchangeably.
//!
//! Predefined tags with an explicit length:
//!
#![feature(io)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(rustc_private)]
#![feature(staged_api)]
#[derive(Clone, Copy)]
pub struct Doc<'a> {
pub data: &'a [u8],
- pub start: uint,
- pub end: uint,
+ pub start: usize,
+ pub end: usize,
}
impl<'doc> Doc<'doc> {
Doc { data: data, start: 0, end: data.len() }
}
- pub fn get<'a>(&'a self, tag: uint) -> Doc<'a> {
+ pub fn get<'a>(&'a self, tag: usize) -> Doc<'a> {
reader::get_doc(*self, tag)
}
}
pub struct TaggedDoc<'a> {
- tag: uint,
+ tag: usize,
pub doc: Doc<'a>,
}
EsOpaque = 0x17,
}
-const NUM_TAGS: uint = 0x1000;
-const NUM_IMPLICIT_TAGS: uint = 0x0e;
+const NUM_TAGS: usize = 0x1000;
+const NUM_IMPLICIT_TAGS: usize = 0x0e;
static TAG_IMPLICIT_LEN: [i8; NUM_IMPLICIT_TAGS] = [
1, 2, 4, 8, // EsU*
#[derive(Debug)]
pub enum Error {
- IntTooBig(uint),
- InvalidTag(uint),
+ IntTooBig(usize),
+ InvalidTag(usize),
Expected(String),
IoError(std::io::Error),
ApplicationError(String)
use std::isize;
use std::mem::transmute;
- use std::num::Int;
use std::slice::bytes;
use serialize;
#[derive(Copy)]
pub struct Res {
- pub val: uint,
- pub next: uint
+ pub val: usize,
+ pub next: usize
}
- pub fn tag_at(data: &[u8], start: uint) -> DecodeResult<Res> {
- let v = data[start] as uint;
+ pub fn tag_at(data: &[u8], start: usize) -> DecodeResult<Res> {
+ let v = data[start] as usize;
if v < 0xf0 {
Ok(Res { val: v, next: start + 1 })
} else if v > 0xf0 {
- Ok(Res { val: ((v & 0xf) << 8) | data[start + 1] as uint, next: start + 2 })
+ Ok(Res { val: ((v & 0xf) << 8) | data[start + 1] as usize, next: start + 2 })
} else {
// every tag starting with byte 0xf0 is an overlong form, which is prohibited.
Err(InvalidTag(v))
}
#[inline(never)]
- fn vuint_at_slow(data: &[u8], start: uint) -> DecodeResult<Res> {
+ fn vuint_at_slow(data: &[u8], start: usize) -> DecodeResult<Res> {
let a = data[start];
if a & 0x80 != 0 {
- return Ok(Res {val: (a & 0x7f) as uint, next: start + 1});
+ return Ok(Res {val: (a & 0x7f) as usize, next: start + 1});
}
if a & 0x40 != 0 {
- return Ok(Res {val: ((a & 0x3f) as uint) << 8 |
- (data[start + 1] as uint),
+ return Ok(Res {val: ((a & 0x3f) as usize) << 8 |
+ (data[start + 1] as usize),
next: start + 2});
}
if a & 0x20 != 0 {
- return Ok(Res {val: ((a & 0x1f) as uint) << 16 |
- (data[start + 1] as uint) << 8 |
- (data[start + 2] as uint),
+ return Ok(Res {val: ((a & 0x1f) as usize) << 16 |
+ (data[start + 1] as usize) << 8 |
+ (data[start + 2] as usize),
next: start + 3});
}
if a & 0x10 != 0 {
- return Ok(Res {val: ((a & 0x0f) as uint) << 24 |
- (data[start + 1] as uint) << 16 |
- (data[start + 2] as uint) << 8 |
- (data[start + 3] as uint),
+ return Ok(Res {val: ((a & 0x0f) as usize) << 24 |
+ (data[start + 1] as usize) << 16 |
+ (data[start + 2] as usize) << 8 |
+ (data[start + 3] as usize),
next: start + 4});
}
- Err(IntTooBig(a as uint))
+ Err(IntTooBig(a as usize))
}
- pub fn vuint_at(data: &[u8], start: uint) -> DecodeResult<Res> {
+ pub fn vuint_at(data: &[u8], start: usize) -> DecodeResult<Res> {
if data.len() - start < 4 {
return vuint_at_slow(data, start);
}
// most significant bit is set etc. we can replace up to three
// "and+branch" with a single table lookup which gives us a measured
// speedup of around 2x on x86_64.
- static SHIFT_MASK_TABLE: [(uint, u32); 16] = [
+ static SHIFT_MASK_TABLE: [(usize, u32); 16] = [
(0, 0x0), (0, 0x0fffffff),
(8, 0x1fffff), (8, 0x1fffff),
(16, 0x3fff), (16, 0x3fff), (16, 0x3fff), (16, 0x3fff),
];
unsafe {
- let ptr = data.as_ptr().offset(start as int) as *const u32;
- let val = Int::from_be(*ptr);
+ let ptr = data.as_ptr().offset(start as isize) as *const u32;
+ let val = u32::from_be(*ptr);
- let i = (val >> 28) as uint;
+ let i = (val >> 28) as usize;
let (shift, mask) = SHIFT_MASK_TABLE[i];
Ok(Res {
val: ((val >> shift) & mask) as usize,
pub fn tag_len_at(data: &[u8], tag: Res) -> DecodeResult<Res> {
if tag.val < NUM_IMPLICIT_TAGS && TAG_IMPLICIT_LEN[tag.val] >= 0 {
- Ok(Res { val: TAG_IMPLICIT_LEN[tag.val] as uint, next: tag.next })
+ Ok(Res { val: TAG_IMPLICIT_LEN[tag.val] as usize, next: tag.next })
} else {
vuint_at(data, tag.next)
}
}
- pub fn doc_at<'a>(data: &'a [u8], start: uint) -> DecodeResult<TaggedDoc<'a>> {
+ pub fn doc_at<'a>(data: &'a [u8], start: usize) -> DecodeResult<TaggedDoc<'a>> {
let elt_tag = try!(tag_at(data, start));
let elt_size = try!(tag_len_at(data, elt_tag));
let end = elt_size.next + elt_size.val;
})
}
- pub fn maybe_get_doc<'a>(d: Doc<'a>, tg: uint) -> Option<Doc<'a>> {
+ pub fn maybe_get_doc<'a>(d: Doc<'a>, tg: usize) -> Option<Doc<'a>> {
let mut pos = d.start;
while pos < d.end {
let elt_tag = try_or!(tag_at(d.data, pos), None);
None
}
- pub fn get_doc<'a>(d: Doc<'a>, tg: uint) -> Doc<'a> {
+ pub fn get_doc<'a>(d: Doc<'a>, tg: usize) -> Doc<'a> {
match maybe_get_doc(d, tg) {
Some(d) => d,
None => {
}
pub fn docs<F>(d: Doc, mut it: F) -> bool where
- F: FnMut(uint, Doc) -> bool,
+ F: FnMut(usize, Doc) -> bool,
{
let mut pos = d.start;
while pos < d.end {
return true;
}
- pub fn tagged_docs<F>(d: Doc, tg: uint, mut it: F) -> bool where
+ pub fn tagged_docs<F>(d: Doc, tg: usize, mut it: F) -> bool where
F: FnMut(Doc) -> bool,
{
let mut pos = d.start;
pub fn doc_as_u16(d: Doc) -> u16 {
assert_eq!(d.end, d.start + 2);
let mut b = [0; 2];
- bytes::copy_memory(&mut b, &d.data[d.start..d.end]);
+ bytes::copy_memory(&d.data[d.start..d.end], &mut b);
unsafe { (*(b.as_ptr() as *const u16)).to_be() }
}
pub fn doc_as_u32(d: Doc) -> u32 {
assert_eq!(d.end, d.start + 4);
let mut b = [0; 4];
- bytes::copy_memory(&mut b, &d.data[d.start..d.end]);
+ bytes::copy_memory(&d.data[d.start..d.end], &mut b);
unsafe { (*(b.as_ptr() as *const u32)).to_be() }
}
pub fn doc_as_u64(d: Doc) -> u64 {
assert_eq!(d.end, d.start + 8);
let mut b = [0; 8];
- bytes::copy_memory(&mut b, &d.data[d.start..d.end]);
+ bytes::copy_memory(&d.data[d.start..d.end], &mut b);
unsafe { (*(b.as_ptr() as *const u64)).to_be() }
}
pub struct Decoder<'a> {
parent: Doc<'a>,
- pos: uint,
+ pos: usize,
}
impl<'doc> Decoder<'doc> {
r_tag,
r_doc.start,
r_doc.end);
- if r_tag != (exp_tag as uint) {
+ if r_tag != (exp_tag as usize) {
return Err(Expected(format!("expected EBML doc with tag {:?} but \
found tag {:?}", exp_tag, r_tag)));
}
Ok(r)
}
- fn _next_sub(&mut self) -> DecodeResult<uint> {
+ fn _next_sub(&mut self) -> DecodeResult<usize> {
// empty vector/map optimization
if self.parent.is_empty() {
return Ok(0);
let TaggedDoc { tag: r_tag, doc: r_doc } =
try!(doc_at(self.parent.data, self.pos));
- let r = if r_tag == (EsSub8 as uint) {
- doc_as_u8(r_doc) as uint
- } else if r_tag == (EsSub32 as uint) {
- doc_as_u32(r_doc) as uint
+ let r = if r_tag == (EsSub8 as usize) {
+ doc_as_u8(r_doc) as usize
+ } else if r_tag == (EsSub32 as usize) {
+ doc_as_u32(r_doc) as usize
} else {
return Err(Expected(format!("expected EBML doc with tag {:?} or {:?} but \
found tag {:?}", EsSub8, EsSub32, r_tag)));
let TaggedDoc { tag: r_tag, doc: r_doc } =
try!(doc_at(self.parent.data, self.pos));
- let r = if first_tag as uint <= r_tag && r_tag <= last_tag as uint {
- match r_tag - first_tag as uint {
+ let r = if first_tag as usize <= r_tag && r_tag <= last_tag as usize {
+ match r_tag - first_tag as usize {
0 => doc_as_u8(r_doc) as u64,
1 => doc_as_u16(r_doc) as u64,
2 => doc_as_u32(r_doc) as u64,
fn read_u32(&mut self) -> DecodeResult<u32> { Ok(try!(self._next_int(EsU8, EsU32)) as u32) }
fn read_u16(&mut self) -> DecodeResult<u16> { Ok(try!(self._next_int(EsU8, EsU16)) as u16) }
fn read_u8(&mut self) -> DecodeResult<u8> { Ok(doc_as_u8(try!(self.next_doc(EsU8)))) }
- fn read_uint(&mut self) -> DecodeResult<uint> {
+ fn read_uint(&mut self) -> DecodeResult<usize> {
let v = try!(self._next_int(EsU8, EsU64));
if v > (::std::usize::MAX as u64) {
- Err(IntTooBig(v as uint))
+ Err(IntTooBig(v as usize))
} else {
- Ok(v as uint)
+ Ok(v as usize)
}
}
fn read_i32(&mut self) -> DecodeResult<i32> { Ok(try!(self._next_int(EsI8, EsI32)) as i32) }
fn read_i16(&mut self) -> DecodeResult<i16> { Ok(try!(self._next_int(EsI8, EsI16)) as i16) }
fn read_i8(&mut self) -> DecodeResult<i8> { Ok(doc_as_u8(try!(self.next_doc(EsI8))) as i8) }
- fn read_int(&mut self) -> DecodeResult<int> {
+ fn read_int(&mut self) -> DecodeResult<isize> {
let v = try!(self._next_int(EsI8, EsI64)) as i64;
if v > (isize::MAX as i64) || v < (isize::MIN as i64) {
debug!("FIXME \\#6122: Removing this makes this function miscompile");
- Err(IntTooBig(v as uint))
+ Err(IntTooBig(v as usize))
} else {
- Ok(v as int)
+ Ok(v as isize)
}
}
fn read_enum_variant<T, F>(&mut self, _: &[&str],
mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
+ where F: FnMut(&mut Decoder<'doc>, usize) -> DecodeResult<T>,
{
debug!("read_enum_variant()");
let idx = try!(self._next_sub());
f(self, idx)
}
- fn read_enum_variant_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_enum_variant_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_enum_variant_arg(idx={})", idx);
fn read_enum_struct_variant<T, F>(&mut self, _: &[&str],
mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
+ where F: FnMut(&mut Decoder<'doc>, usize) -> DecodeResult<T>,
{
debug!("read_enum_struct_variant()");
let idx = try!(self._next_sub());
fn read_enum_struct_variant_field<T, F>(&mut self,
name: &str,
- idx: uint,
+ idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
f(self)
}
- fn read_struct<T, F>(&mut self, name: &str, _: uint, f: F) -> DecodeResult<T> where
+ fn read_struct<T, F>(&mut self, name: &str, _: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_struct(name={})", name);
f(self)
}
- fn read_struct_field<T, F>(&mut self, name: &str, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_struct_field<T, F>(&mut self, name: &str, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_struct_field(name={}, idx={})", name, idx);
f(self)
}
- fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
+ fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple()");
})
}
- fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple_arg(idx={})", idx);
self.read_seq_elt(idx, f)
}
- fn read_tuple_struct<T, F>(&mut self, name: &str, len: uint, f: F) -> DecodeResult<T> where
+ fn read_tuple_struct<T, F>(&mut self, name: &str, len: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_tuple_struct(name={})", name);
}
fn read_tuple_struct_arg<T, F>(&mut self,
- idx: uint,
+ idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
}
fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
+ F: FnOnce(&mut Decoder<'doc>, usize) -> DecodeResult<T>,
{
debug!("read_seq()");
self.push_doc(EsVec, move |d| {
})
}
- fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_seq_elt(idx={})", idx);
}
fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder<'doc>, uint) -> DecodeResult<T>,
+ F: FnOnce(&mut Decoder<'doc>, usize) -> DecodeResult<T>,
{
debug!("read_map()");
self.push_doc(EsMap, move |d| {
})
}
- fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_map_elt_key(idx={})", idx);
self.push_doc(EsMapKey, f)
}
- fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder<'doc>) -> DecodeResult<T>,
{
debug!("read_map_elt_val(idx={})", idx);
pub mod writer {
use std::mem;
- use std::num::Int;
use std::io::prelude::*;
use std::io::{self, SeekFrom, Cursor};
use std::slice::bytes;
relax_limit: u64, // do not move encoded bytes before this position
}
- fn write_tag<W: Write>(w: &mut W, n: uint) -> EncodeResult {
+ fn write_tag<W: Write>(w: &mut W, n: usize) -> EncodeResult {
if n < 0xf0 {
w.write_all(&[n as u8])
} else if 0x100 <= n && n < NUM_TAGS {
}
}
- fn write_sized_vuint<W: Write>(w: &mut W, n: uint, size: uint) -> EncodeResult {
+ fn write_sized_vuint<W: Write>(w: &mut W, n: usize, size: usize) -> EncodeResult {
match size {
1 => w.write_all(&[0x80 | (n as u8)]),
2 => w.write_all(&[0x40 | ((n >> 8) as u8), n as u8]),
4 => w.write_all(&[0x10 | ((n >> 24) as u8), (n >> 16) as u8,
(n >> 8) as u8, n as u8]),
_ => Err(io::Error::new(io::ErrorKind::Other,
- "int too big", Some(n.to_string())))
+ "isize too big", Some(n.to_string())))
}
}
- fn write_vuint<W: Write>(w: &mut W, n: uint) -> EncodeResult {
+ fn write_vuint<W: Write>(w: &mut W, n: usize) -> EncodeResult {
if n < 0x7f { return write_sized_vuint(w, n, 1); }
if n < 0x4000 { return write_sized_vuint(w, n, 2); }
if n < 0x200000 { return write_sized_vuint(w, n, 3); }
if n < 0x10000000 { return write_sized_vuint(w, n, 4); }
- Err(io::Error::new(io::ErrorKind::Other, "int too big",
+ Err(io::Error::new(io::ErrorKind::Other, "isize too big",
Some(n.to_string())))
}
}
}
- pub fn start_tag(&mut self, tag_id: uint) -> EncodeResult {
+ pub fn start_tag(&mut self, tag_id: usize) -> EncodeResult {
debug!("Start tag {:?}", tag_id);
assert!(tag_id >= NUM_IMPLICIT_TAGS);
// relax the size encoding for small tags (bigger tags are costly to move).
// we should never try to move the stable positions, however.
- const RELAX_MAX_SIZE: uint = 0x100;
+ const RELAX_MAX_SIZE: usize = 0x100;
if size <= RELAX_MAX_SIZE && last_size_pos >= self.relax_limit {
// we can't alter the buffer in place, so have a temporary buffer
let mut buf = [0u8; RELAX_MAX_SIZE];
{
let last_size_pos = last_size_pos as usize;
- let data = &self.writer.get_ref()[last_size_pos+4..cur_pos as uint];
- bytes::copy_memory(&mut buf, data);
+ let data = &self.writer.get_ref()[last_size_pos+4..cur_pos as usize];
+ bytes::copy_memory(data, &mut buf);
}
// overwrite the size and data and continue
Ok(())
}
- pub fn wr_tag<F>(&mut self, tag_id: uint, blk: F) -> EncodeResult where
+ pub fn wr_tag<F>(&mut self, tag_id: usize, blk: F) -> EncodeResult where
F: FnOnce() -> EncodeResult,
{
try!(self.start_tag(tag_id));
self.end_tag()
}
- pub fn wr_tagged_bytes(&mut self, tag_id: uint, b: &[u8]) -> EncodeResult {
+ pub fn wr_tagged_bytes(&mut self, tag_id: usize, b: &[u8]) -> EncodeResult {
assert!(tag_id >= NUM_IMPLICIT_TAGS);
try!(write_tag(self.writer, tag_id));
try!(write_vuint(self.writer, b.len()));
self.writer.write_all(b)
}
- pub fn wr_tagged_u64(&mut self, tag_id: uint, v: u64) -> EncodeResult {
+ pub fn wr_tagged_u64(&mut self, tag_id: usize, v: u64) -> EncodeResult {
let bytes: [u8; 8] = unsafe { mem::transmute(v.to_be()) };
self.wr_tagged_bytes(tag_id, &bytes)
}
- pub fn wr_tagged_u32(&mut self, tag_id: uint, v: u32) -> EncodeResult{
+ pub fn wr_tagged_u32(&mut self, tag_id: usize, v: u32) -> EncodeResult{
let bytes: [u8; 4] = unsafe { mem::transmute(v.to_be()) };
self.wr_tagged_bytes(tag_id, &bytes)
}
- pub fn wr_tagged_u16(&mut self, tag_id: uint, v: u16) -> EncodeResult {
+ pub fn wr_tagged_u16(&mut self, tag_id: usize, v: u16) -> EncodeResult {
let bytes: [u8; 2] = unsafe { mem::transmute(v.to_be()) };
self.wr_tagged_bytes(tag_id, &bytes)
}
- pub fn wr_tagged_u8(&mut self, tag_id: uint, v: u8) -> EncodeResult {
+ pub fn wr_tagged_u8(&mut self, tag_id: usize, v: u8) -> EncodeResult {
self.wr_tagged_bytes(tag_id, &[v])
}
- pub fn wr_tagged_i64(&mut self, tag_id: uint, v: i64) -> EncodeResult {
+ pub fn wr_tagged_i64(&mut self, tag_id: usize, v: i64) -> EncodeResult {
self.wr_tagged_u64(tag_id, v as u64)
}
- pub fn wr_tagged_i32(&mut self, tag_id: uint, v: i32) -> EncodeResult {
+ pub fn wr_tagged_i32(&mut self, tag_id: usize, v: i32) -> EncodeResult {
self.wr_tagged_u32(tag_id, v as u32)
}
- pub fn wr_tagged_i16(&mut self, tag_id: uint, v: i16) -> EncodeResult {
+ pub fn wr_tagged_i16(&mut self, tag_id: usize, v: i16) -> EncodeResult {
self.wr_tagged_u16(tag_id, v as u16)
}
- pub fn wr_tagged_i8(&mut self, tag_id: uint, v: i8) -> EncodeResult {
+ pub fn wr_tagged_i8(&mut self, tag_id: usize, v: i8) -> EncodeResult {
self.wr_tagged_bytes(tag_id, &[v as u8])
}
- pub fn wr_tagged_str(&mut self, tag_id: uint, v: &str) -> EncodeResult {
+ pub fn wr_tagged_str(&mut self, tag_id: usize, v: &str) -> EncodeResult {
self.wr_tagged_bytes(tag_id, v.as_bytes())
}
// for auto-serialization
- fn wr_tagged_raw_bytes(&mut self, tag_id: uint, b: &[u8]) -> EncodeResult {
+ fn wr_tagged_raw_bytes(&mut self, tag_id: usize, b: &[u8]) -> EncodeResult {
try!(write_tag(self.writer, tag_id));
self.writer.write_all(b)
}
- fn wr_tagged_raw_u64(&mut self, tag_id: uint, v: u64) -> EncodeResult {
+ fn wr_tagged_raw_u64(&mut self, tag_id: usize, v: u64) -> EncodeResult {
let bytes: [u8; 8] = unsafe { mem::transmute(v.to_be()) };
self.wr_tagged_raw_bytes(tag_id, &bytes)
}
- fn wr_tagged_raw_u32(&mut self, tag_id: uint, v: u32) -> EncodeResult{
+ fn wr_tagged_raw_u32(&mut self, tag_id: usize, v: u32) -> EncodeResult{
let bytes: [u8; 4] = unsafe { mem::transmute(v.to_be()) };
self.wr_tagged_raw_bytes(tag_id, &bytes)
}
- fn wr_tagged_raw_u16(&mut self, tag_id: uint, v: u16) -> EncodeResult {
+ fn wr_tagged_raw_u16(&mut self, tag_id: usize, v: u16) -> EncodeResult {
let bytes: [u8; 2] = unsafe { mem::transmute(v.to_be()) };
self.wr_tagged_raw_bytes(tag_id, &bytes)
}
- fn wr_tagged_raw_u8(&mut self, tag_id: uint, v: u8) -> EncodeResult {
+ fn wr_tagged_raw_u8(&mut self, tag_id: usize, v: u8) -> EncodeResult {
self.wr_tagged_raw_bytes(tag_id, &[v])
}
- fn wr_tagged_raw_i64(&mut self, tag_id: uint, v: i64) -> EncodeResult {
+ fn wr_tagged_raw_i64(&mut self, tag_id: usize, v: i64) -> EncodeResult {
self.wr_tagged_raw_u64(tag_id, v as u64)
}
- fn wr_tagged_raw_i32(&mut self, tag_id: uint, v: i32) -> EncodeResult {
+ fn wr_tagged_raw_i32(&mut self, tag_id: usize, v: i32) -> EncodeResult {
self.wr_tagged_raw_u32(tag_id, v as u32)
}
- fn wr_tagged_raw_i16(&mut self, tag_id: uint, v: i16) -> EncodeResult {
+ fn wr_tagged_raw_i16(&mut self, tag_id: usize, v: i16) -> EncodeResult {
self.wr_tagged_raw_u16(tag_id, v as u16)
}
- fn wr_tagged_raw_i8(&mut self, tag_id: uint, v: i8) -> EncodeResult {
+ fn wr_tagged_raw_i8(&mut self, tag_id: usize, v: i8) -> EncodeResult {
self.wr_tagged_raw_bytes(tag_id, &[v as u8])
}
impl<'a> Encoder<'a> {
// used internally to emit things like the vector length and so on
- fn _emit_tagged_sub(&mut self, v: uint) -> EncodeResult {
+ fn _emit_tagged_sub(&mut self, v: usize) -> EncodeResult {
if let Some(v) = v.to_u8() {
- self.wr_tagged_raw_u8(EsSub8 as uint, v)
+ self.wr_tagged_raw_u8(EsSub8 as usize, v)
} else if let Some(v) = v.to_u32() {
- self.wr_tagged_raw_u32(EsSub32 as uint, v)
+ self.wr_tagged_raw_u32(EsSub32 as usize, v)
} else {
Err(io::Error::new(io::ErrorKind::Other,
"length or variant id too big",
pub fn emit_opaque<F>(&mut self, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder) -> EncodeResult,
{
- try!(self.start_tag(EsOpaque as uint));
+ try!(self.start_tag(EsOpaque as usize));
try!(f(self));
self.end_tag()
}
Ok(())
}
- fn emit_uint(&mut self, v: uint) -> EncodeResult {
+ fn emit_uint(&mut self, v: usize) -> EncodeResult {
self.emit_u64(v as u64)
}
fn emit_u64(&mut self, v: u64) -> EncodeResult {
match v.to_u32() {
Some(v) => self.emit_u32(v),
- None => self.wr_tagged_raw_u64(EsU64 as uint, v)
+ None => self.wr_tagged_raw_u64(EsU64 as usize, v)
}
}
fn emit_u32(&mut self, v: u32) -> EncodeResult {
match v.to_u16() {
Some(v) => self.emit_u16(v),
- None => self.wr_tagged_raw_u32(EsU32 as uint, v)
+ None => self.wr_tagged_raw_u32(EsU32 as usize, v)
}
}
fn emit_u16(&mut self, v: u16) -> EncodeResult {
match v.to_u8() {
Some(v) => self.emit_u8(v),
- None => self.wr_tagged_raw_u16(EsU16 as uint, v)
+ None => self.wr_tagged_raw_u16(EsU16 as usize, v)
}
}
fn emit_u8(&mut self, v: u8) -> EncodeResult {
- self.wr_tagged_raw_u8(EsU8 as uint, v)
+ self.wr_tagged_raw_u8(EsU8 as usize, v)
}
- fn emit_int(&mut self, v: int) -> EncodeResult {
+ fn emit_int(&mut self, v: isize) -> EncodeResult {
self.emit_i64(v as i64)
}
fn emit_i64(&mut self, v: i64) -> EncodeResult {
match v.to_i32() {
Some(v) => self.emit_i32(v),
- None => self.wr_tagged_raw_i64(EsI64 as uint, v)
+ None => self.wr_tagged_raw_i64(EsI64 as usize, v)
}
}
fn emit_i32(&mut self, v: i32) -> EncodeResult {
match v.to_i16() {
Some(v) => self.emit_i16(v),
- None => self.wr_tagged_raw_i32(EsI32 as uint, v)
+ None => self.wr_tagged_raw_i32(EsI32 as usize, v)
}
}
fn emit_i16(&mut self, v: i16) -> EncodeResult {
match v.to_i8() {
Some(v) => self.emit_i8(v),
- None => self.wr_tagged_raw_i16(EsI16 as uint, v)
+ None => self.wr_tagged_raw_i16(EsI16 as usize, v)
}
}
fn emit_i8(&mut self, v: i8) -> EncodeResult {
- self.wr_tagged_raw_i8(EsI8 as uint, v)
+ self.wr_tagged_raw_i8(EsI8 as usize, v)
}
fn emit_bool(&mut self, v: bool) -> EncodeResult {
- self.wr_tagged_raw_u8(EsBool as uint, v as u8)
+ self.wr_tagged_raw_u8(EsBool as usize, v as u8)
}
fn emit_f64(&mut self, v: f64) -> EncodeResult {
let bits = unsafe { mem::transmute(v) };
- self.wr_tagged_raw_u64(EsF64 as uint, bits)
+ self.wr_tagged_raw_u64(EsF64 as usize, bits)
}
fn emit_f32(&mut self, v: f32) -> EncodeResult {
let bits = unsafe { mem::transmute(v) };
- self.wr_tagged_raw_u32(EsF32 as uint, bits)
+ self.wr_tagged_raw_u32(EsF32 as usize, bits)
}
fn emit_char(&mut self, v: char) -> EncodeResult {
- self.wr_tagged_raw_u32(EsChar as uint, v as u32)
+ self.wr_tagged_raw_u32(EsChar as usize, v as u32)
}
fn emit_str(&mut self, v: &str) -> EncodeResult {
- self.wr_tagged_str(EsStr as uint, v)
+ self.wr_tagged_str(EsStr as usize, v)
}
fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
- try!(self.start_tag(EsEnum as uint));
+ try!(self.start_tag(EsEnum as usize));
try!(f(self));
self.end_tag()
}
fn emit_enum_variant<F>(&mut self,
_: &str,
- v_id: uint,
- _: uint,
+ v_id: usize,
+ _: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
f(self)
}
- fn emit_enum_variant_arg<F>(&mut self, _: uint, f: F) -> EncodeResult where
+ fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
f(self)
fn emit_enum_struct_variant<F>(&mut self,
v_name: &str,
- v_id: uint,
- cnt: uint,
+ v_id: usize,
+ cnt: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str,
- idx: uint,
+ idx: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_enum_variant_arg(idx, f)
}
- fn emit_struct<F>(&mut self, _: &str, _len: uint, f: F) -> EncodeResult where
+ fn emit_struct<F>(&mut self, _: &str, _len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
f(self)
}
- fn emit_struct_field<F>(&mut self, _name: &str, _: uint, f: F) -> EncodeResult where
+ fn emit_struct_field<F>(&mut self, _name: &str, _: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
f(self)
}
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_seq(len, f)
}
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_seq_elt(idx, f)
}
- fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
+ fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_seq(len, f)
}
- fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_seq_elt(idx, f)
self.emit_enum_variant("Some", 1, 1, f)
}
- fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if len == 0 {
// empty vector optimization
- return self.wr_tagged_bytes(EsVec as uint, &[]);
+ return self.wr_tagged_bytes(EsVec as usize, &[]);
}
- try!(self.start_tag(EsVec as uint));
+ try!(self.start_tag(EsVec as usize));
try!(self._emit_tagged_sub(len));
try!(f(self));
self.end_tag()
}
- fn emit_seq_elt<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
- try!(self.start_tag(EsVecElt as uint));
+ try!(self.start_tag(EsVecElt as usize));
try!(f(self));
self.end_tag()
}
- fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if len == 0 {
// empty map optimization
- return self.wr_tagged_bytes(EsMap as uint, &[]);
+ return self.wr_tagged_bytes(EsMap as usize, &[]);
}
- try!(self.start_tag(EsMap as uint));
+ try!(self.start_tag(EsMap as usize));
try!(self._emit_tagged_sub(len));
try!(f(self));
self.end_tag()
}
- fn emit_map_elt_key<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
- try!(self.start_tag(EsMapKey as uint));
+ try!(self.start_tag(EsMapKey as usize));
try!(f(self));
self.end_tag()
}
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
- try!(self.start_tag(EsMapVal as uint));
+ try!(self.start_tag(EsMapVal as usize));
try!(f(self));
self.end_tag()
}
#[test]
fn test_option_int() {
- fn test_v(v: Option<int>) {
+ fn test_v(v: Option<isize>) {
debug!("v == {:?}", v);
let mut wr = Cursor::new(Vec::new());
{
#![feature(collections)]
#![feature(core)]
#![feature(hash)]
-#![feature(int_uint)]
#![feature(libc)]
-#![feature(old_path)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
#![feature(str_char)]
#![feature(convert)]
#![feature(into_cow)]
+#![feature(slice_patterns)]
#![cfg_attr(test, feature(test))]
#![allow(trivial_casts)]
-#![allow(trivial_numeric_casts)]
extern crate arena;
extern crate flate;
#[macro_use] extern crate syntax;
#[macro_use] #[no_link] extern crate rustc_bitflags;
-extern crate "serialize" as rustc_serialize; // used by deriving
+extern crate serialize as rustc_serialize; // used by deriving
#[cfg(test)]
extern crate test;
declare_lint! {
pub TRIVIAL_CASTS,
- Warn,
+ Allow,
"detects trivial casts which could be removed"
}
declare_lint! {
pub TRIVIAL_NUMERIC_CASTS,
- Warn,
+ Allow,
"detects trivial casts of numeric types which could be removed"
}
/// Does nothing as a lint pass, but registers some `Lint`s
// 0xf0..0xff: internally used by RBML to encode 0x100..0xfff in two bytes
// 0x100..0xfff: free for use, preferred for infrequent tags
-pub const tag_items: uint = 0x100; // top-level only
+pub const tag_items: usize = 0x100; // top-level only
-pub const tag_paths_data_name: uint = 0x20;
+pub const tag_paths_data_name: usize = 0x20;
-pub const tag_def_id: uint = 0x21;
+pub const tag_def_id: usize = 0x21;
-pub const tag_items_data: uint = 0x22;
+pub const tag_items_data: usize = 0x22;
-pub const tag_items_data_item: uint = 0x23;
+pub const tag_items_data_item: usize = 0x23;
-pub const tag_items_data_item_family: uint = 0x24;
+pub const tag_items_data_item_family: usize = 0x24;
-pub const tag_items_data_item_type: uint = 0x25;
+pub const tag_items_data_item_type: usize = 0x25;
-pub const tag_items_data_item_symbol: uint = 0x26;
+pub const tag_items_data_item_symbol: usize = 0x26;
-pub const tag_items_data_item_variant: uint = 0x27;
+pub const tag_items_data_item_variant: usize = 0x27;
-pub const tag_items_data_parent_item: uint = 0x28;
+pub const tag_items_data_parent_item: usize = 0x28;
-pub const tag_items_data_item_is_tuple_struct_ctor: uint = 0x29;
+pub const tag_items_data_item_is_tuple_struct_ctor: usize = 0x29;
-pub const tag_index: uint = 0x2a;
+pub const tag_index: usize = 0x2a;
-pub const tag_index_buckets: uint = 0x2b;
+pub const tag_index_buckets: usize = 0x2b;
-pub const tag_index_buckets_bucket: uint = 0x2c;
+pub const tag_index_buckets_bucket: usize = 0x2c;
-pub const tag_index_buckets_bucket_elt: uint = 0x2d;
+pub const tag_index_buckets_bucket_elt: usize = 0x2d;
-pub const tag_index_table: uint = 0x2e;
+pub const tag_index_table: usize = 0x2e;
-pub const tag_meta_item_name_value: uint = 0x2f;
+pub const tag_meta_item_name_value: usize = 0x2f;
-pub const tag_meta_item_name: uint = 0x30;
+pub const tag_meta_item_name: usize = 0x30;
-pub const tag_meta_item_value: uint = 0x31;
+pub const tag_meta_item_value: usize = 0x31;
-pub const tag_attributes: uint = 0x101; // top-level only
+pub const tag_attributes: usize = 0x101; // top-level only
-pub const tag_attribute: uint = 0x32;
+pub const tag_attribute: usize = 0x32;
-pub const tag_meta_item_word: uint = 0x33;
+pub const tag_meta_item_word: usize = 0x33;
-pub const tag_meta_item_list: uint = 0x34;
+pub const tag_meta_item_list: usize = 0x34;
// The list of crates that this crate depends on
-pub const tag_crate_deps: uint = 0x102; // top-level only
+pub const tag_crate_deps: usize = 0x102; // top-level only
// A single crate dependency
-pub const tag_crate_dep: uint = 0x35;
+pub const tag_crate_dep: usize = 0x35;
-pub const tag_crate_hash: uint = 0x103; // top-level only
-pub const tag_crate_crate_name: uint = 0x104; // top-level only
+pub const tag_crate_hash: usize = 0x103; // top-level only
+pub const tag_crate_crate_name: usize = 0x104; // top-level only
-pub const tag_crate_dep_crate_name: uint = 0x36;
-pub const tag_crate_dep_hash: uint = 0x37;
+pub const tag_crate_dep_crate_name: usize = 0x36;
+pub const tag_crate_dep_hash: usize = 0x37;
-pub const tag_mod_impl: uint = 0x38;
+pub const tag_mod_impl: usize = 0x38;
-pub const tag_item_trait_item: uint = 0x39;
+pub const tag_item_trait_item: usize = 0x39;
-pub const tag_item_trait_ref: uint = 0x3a;
+pub const tag_item_trait_ref: usize = 0x3a;
// discriminator value for variants
-pub const tag_disr_val: uint = 0x3c;
+pub const tag_disr_val: usize = 0x3c;
// used to encode ast_map::PathElem
-pub const tag_path: uint = 0x3d;
-pub const tag_path_len: uint = 0x3e;
-pub const tag_path_elem_mod: uint = 0x3f;
-pub const tag_path_elem_name: uint = 0x40;
-pub const tag_item_field: uint = 0x41;
-pub const tag_item_field_origin: uint = 0x42;
-
-pub const tag_item_variances: uint = 0x43;
+pub const tag_path: usize = 0x3d;
+pub const tag_path_len: usize = 0x3e;
+pub const tag_path_elem_mod: usize = 0x3f;
+pub const tag_path_elem_name: usize = 0x40;
+pub const tag_item_field: usize = 0x41;
+pub const tag_item_field_origin: usize = 0x42;
+
+pub const tag_item_variances: usize = 0x43;
/*
trait items contain tag_item_trait_item elements,
impl items contain tag_item_impl_item elements, and classes
both, tag_item_trait_item and tag_item_impl_item have to be two
different tags.
*/
-pub const tag_item_impl_item: uint = 0x44;
-pub const tag_item_trait_method_explicit_self: uint = 0x45;
+pub const tag_item_impl_item: usize = 0x44;
+pub const tag_item_trait_method_explicit_self: usize = 0x45;
// Reexports are found within module tags. Each reexport contains def_ids
// and names.
-pub const tag_items_data_item_reexport: uint = 0x46;
-pub const tag_items_data_item_reexport_def_id: uint = 0x47;
-pub const tag_items_data_item_reexport_name: uint = 0x48;
+pub const tag_items_data_item_reexport: usize = 0x46;
+pub const tag_items_data_item_reexport_def_id: usize = 0x47;
+pub const tag_items_data_item_reexport_name: usize = 0x48;
// used to encode crate_ctxt side tables
#[derive(Copy, PartialEq, FromPrimitive)]
-#[repr(uint)]
+#[repr(usize)]
pub enum astencode_tag { // Reserves 0x50 -- 0x6f
tag_ast = 0x50,
tag_table_const_qualif = 0x69,
}
-pub const tag_item_trait_item_sort: uint = 0x70;
+pub const tag_item_trait_item_sort: usize = 0x70;
-pub const tag_item_trait_parent_sort: uint = 0x71;
+pub const tag_item_trait_parent_sort: usize = 0x71;
-pub const tag_item_impl_type_basename: uint = 0x72;
+pub const tag_item_impl_type_basename: usize = 0x72;
-pub const tag_crate_triple: uint = 0x105; // top-level only
+pub const tag_crate_triple: usize = 0x105; // top-level only
-pub const tag_dylib_dependency_formats: uint = 0x106; // top-level only
+pub const tag_dylib_dependency_formats: usize = 0x106; // top-level only
// Language items are a top-level directory (for speed). Hierarchy:
//
// - tag_lang_items_item_id: u32
// - tag_lang_items_item_node_id: u32
-pub const tag_lang_items: uint = 0x107; // top-level only
-pub const tag_lang_items_item: uint = 0x73;
-pub const tag_lang_items_item_id: uint = 0x74;
-pub const tag_lang_items_item_node_id: uint = 0x75;
-pub const tag_lang_items_missing: uint = 0x76;
+pub const tag_lang_items: usize = 0x107; // top-level only
+pub const tag_lang_items_item: usize = 0x73;
+pub const tag_lang_items_item_id: usize = 0x74;
+pub const tag_lang_items_item_node_id: usize = 0x75;
+pub const tag_lang_items_missing: usize = 0x76;
-pub const tag_item_unnamed_field: uint = 0x77;
-pub const tag_items_data_item_visibility: uint = 0x78;
+pub const tag_item_unnamed_field: usize = 0x77;
+pub const tag_items_data_item_visibility: usize = 0x78;
-pub const tag_item_method_tps: uint = 0x79;
-pub const tag_item_method_fty: uint = 0x7a;
+pub const tag_item_method_tps: usize = 0x79;
+pub const tag_item_method_fty: usize = 0x7a;
-pub const tag_mod_child: uint = 0x7b;
-pub const tag_misc_info: uint = 0x108; // top-level only
-pub const tag_misc_info_crate_items: uint = 0x7c;
+pub const tag_mod_child: usize = 0x7b;
+pub const tag_misc_info: usize = 0x108; // top-level only
+pub const tag_misc_info_crate_items: usize = 0x7c;
-pub const tag_item_method_provided_source: uint = 0x7d;
-pub const tag_item_impl_vtables: uint = 0x7e;
+pub const tag_item_method_provided_source: usize = 0x7d;
+pub const tag_item_impl_vtables: usize = 0x7e;
-pub const tag_impls: uint = 0x109; // top-level only
-pub const tag_impls_impl: uint = 0x7f;
+pub const tag_impls: usize = 0x109; // top-level only
+pub const tag_impls_impl: usize = 0x7f;
-pub const tag_items_data_item_inherent_impl: uint = 0x80;
-pub const tag_items_data_item_extension_impl: uint = 0x81;
+pub const tag_items_data_item_inherent_impl: usize = 0x80;
+pub const tag_items_data_item_extension_impl: usize = 0x81;
-pub const tag_native_libraries: uint = 0x10a; // top-level only
-pub const tag_native_libraries_lib: uint = 0x82;
-pub const tag_native_libraries_name: uint = 0x83;
-pub const tag_native_libraries_kind: uint = 0x84;
+pub const tag_native_libraries: usize = 0x10a; // top-level only
+pub const tag_native_libraries_lib: usize = 0x82;
+pub const tag_native_libraries_name: usize = 0x83;
+pub const tag_native_libraries_kind: usize = 0x84;
-pub const tag_plugin_registrar_fn: uint = 0x10b; // top-level only
+pub const tag_plugin_registrar_fn: usize = 0x10b; // top-level only
-pub const tag_method_argument_names: uint = 0x85;
-pub const tag_method_argument_name: uint = 0x86;
+pub const tag_method_argument_names: usize = 0x85;
+pub const tag_method_argument_name: usize = 0x86;
-pub const tag_reachable_extern_fns: uint = 0x10c; // top-level only
-pub const tag_reachable_extern_fn_id: uint = 0x87;
+pub const tag_reachable_extern_fns: usize = 0x10c; // top-level only
+pub const tag_reachable_extern_fn_id: usize = 0x87;
-pub const tag_items_data_item_stability: uint = 0x88;
+pub const tag_items_data_item_stability: usize = 0x88;
-pub const tag_items_data_item_repr: uint = 0x89;
+pub const tag_items_data_item_repr: usize = 0x89;
#[derive(Clone, Debug)]
pub struct LinkMeta {
pub crate_hash: Svh,
}
-pub const tag_struct_fields: uint = 0x10d; // top-level only
-pub const tag_struct_field: uint = 0x8a;
-pub const tag_struct_field_id: uint = 0x8b;
+pub const tag_struct_fields: usize = 0x10d; // top-level only
+pub const tag_struct_field: usize = 0x8a;
+pub const tag_struct_field_id: usize = 0x8b;
-pub const tag_attribute_is_sugared_doc: uint = 0x8c;
+pub const tag_attribute_is_sugared_doc: usize = 0x8c;
-pub const tag_items_data_region: uint = 0x8e;
+pub const tag_items_data_region: usize = 0x8e;
-pub const tag_region_param_def: uint = 0x8f;
-pub const tag_region_param_def_ident: uint = 0x90;
-pub const tag_region_param_def_def_id: uint = 0x91;
-pub const tag_region_param_def_space: uint = 0x92;
-pub const tag_region_param_def_index: uint = 0x93;
+pub const tag_region_param_def: usize = 0x8f;
+pub const tag_region_param_def_ident: usize = 0x90;
+pub const tag_region_param_def_def_id: usize = 0x91;
+pub const tag_region_param_def_space: usize = 0x92;
+pub const tag_region_param_def_index: usize = 0x93;
-pub const tag_type_param_def: uint = 0x94;
+pub const tag_type_param_def: usize = 0x94;
-pub const tag_item_generics: uint = 0x95;
-pub const tag_method_ty_generics: uint = 0x96;
+pub const tag_item_generics: usize = 0x95;
+pub const tag_method_ty_generics: usize = 0x96;
-pub const tag_predicate: uint = 0x97;
-pub const tag_predicate_space: uint = 0x98;
-pub const tag_predicate_data: uint = 0x99;
+pub const tag_predicate: usize = 0x97;
+pub const tag_predicate_space: usize = 0x98;
+pub const tag_predicate_data: usize = 0x99;
-pub const tag_unsafety: uint = 0x9a;
+pub const tag_unsafety: usize = 0x9a;
-pub const tag_associated_type_names: uint = 0x9b;
-pub const tag_associated_type_name: uint = 0x9c;
+pub const tag_associated_type_names: usize = 0x9b;
+pub const tag_associated_type_name: usize = 0x9c;
-pub const tag_polarity: uint = 0x9d;
+pub const tag_polarity: usize = 0x9d;
-pub const tag_macro_defs: uint = 0x10e; // top-level only
-pub const tag_macro_def: uint = 0x9e;
-pub const tag_macro_def_body: uint = 0x9f;
+pub const tag_macro_defs: usize = 0x10e; // top-level only
+pub const tag_macro_def: usize = 0x9e;
+pub const tag_macro_def_body: usize = 0x9f;
-pub const tag_paren_sugar: uint = 0xa0;
+pub const tag_paren_sugar: usize = 0xa0;
-pub const tag_codemap: uint = 0xa1;
-pub const tag_codemap_filemap: uint = 0xa2;
+pub const tag_codemap: usize = 0xa1;
+pub const tag_codemap_filemap: usize = 0xa2;
-pub const tag_item_super_predicates: uint = 0xa3;
+pub const tag_item_super_predicates: usize = 0xa3;
-pub const tag_defaulted_trait: uint = 0xa4;
+pub const tag_defaulted_trait: usize = 0xa4;
}
pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
- let say = |s: &str, warn: bool| {
+ let say = |s: &str| {
match (sp, sess) {
(_, None) => panic!("{}", s),
- (Some(sp), Some(sess)) if warn => sess.span_warn(sp, s),
(Some(sp), Some(sess)) => sess.span_err(sp, s),
- (None, Some(sess)) if warn => sess.warn(s),
(None, Some(sess)) => sess.err(s),
}
};
if s.len() == 0 {
- say("crate name must not be empty", false);
- } else if s.contains("-") {
- say(&format!("crate names soon cannot contain hyphens: {}", s), true);
+ say("crate name must not be empty");
}
for c in s.chars() {
if c.is_alphanumeric() { continue }
- if c == '_' || c == '-' { continue }
- say(&format!("invalid character `{}` in crate name: `{}`", c, s), false);
+ if c == '_' { continue }
+ say(&format!("invalid character `{}` in crate name: `{}`", c, s));
}
match sess {
Some(sess) => sess.abort_if_errors(),
-> Option<ast::CrateNum> {
let mut ret = None;
self.sess.cstore.iter_crate_data(|cnum, data| {
- // For now we do a "fuzzy match" on crate names by considering
- // hyphens equal to underscores. This is purely meant to be a
- // transitionary feature while we deprecate the quote syntax of
- // `extern crate` statements.
- if data.name != name.replace("-", "_") {
- return
- }
+ if data.name != name { return }
match hash {
Some(hash) if *hash == data.hash() => { ret = Some(cnum); return }
cnum: ast::CrateNum,
f: F)
-> bool where
- F: FnMut(ast::NodeId, uint) -> bool,
+ F: FnMut(ast::NodeId, usize) -> bool,
{
let crate_data = cstore.get_crate_data(cnum);
decoder::each_lang_item(&*crate_data, f)
let len = (((slice[0] as u32) << 24) |
((slice[1] as u32) << 16) |
((slice[2] as u32) << 8) |
- ((slice[3] as u32) << 0)) as uint;
+ ((slice[3] as u32) << 0)) as usize;
if len + 4 <= slice.len() {
&slice[4.. len + 4]
} else {
use std::hash::{self, Hash, SipHasher};
use std::io::prelude::*;
use std::io;
-use std::num::{FromPrimitive, Int};
+use std::num::FromPrimitive;
use std::rc::Rc;
use std::slice::bytes;
use std::str;
fn u32_from_be_bytes(bytes: &[u8]) -> u32 {
let mut b = [0; 4];
- bytes::copy_memory(&mut b, &bytes[..4]);
+ bytes::copy_memory(&bytes[..4], &mut b);
unsafe { (*(b.as_ptr() as *const u32)).to_be() }
}
{
let index = reader::get_doc(d, tag_index);
let table = reader::get_doc(index, tag_index_table);
- let hash_pos = table.start + (hash % 256 * 4) as uint;
- let pos = u32_from_be_bytes(&d.data[hash_pos..]) as uint;
+ let hash_pos = table.start + (hash % 256 * 4) as usize;
+ let pos = u32_from_be_bytes(&d.data[hash_pos..]) as usize;
let tagged_doc = reader::doc_at(d.data, pos).unwrap();
let belt = tag_index_buckets_bucket_elt;
let mut ret = None;
reader::tagged_docs(tagged_doc.doc, belt, |elt| {
- let pos = u32_from_be_bytes(&elt.data[elt.start..]) as uint;
+ let pos = u32_from_be_bytes(&elt.data[elt.start..]) as usize;
if eq_fn(&elt.data[elt.start + 4 .. elt.end]) {
ret = Some(reader::doc_at(d.data, pos).unwrap().doc);
false
let path_doc = reader::get_doc(item_doc, tag_path);
let len_doc = reader::get_doc(path_doc, tag_path_len);
- let len = reader::doc_as_u32(len_doc) as uint;
+ let len = reader::doc_as_u32(len_doc) as usize;
let mut result = Vec::with_capacity(len);
reader::docs(path_doc, |tag, elt_doc| {
/// Iterates over the language items in the given crate.
pub fn each_lang_item<F>(cdata: Cmd, mut f: F) -> bool where
- F: FnMut(ast::NodeId, uint) -> bool,
+ F: FnMut(ast::NodeId, usize) -> bool,
{
let root = rbml::Doc::new(cdata.data());
let lang_items = reader::get_doc(root, tag_lang_items);
reader::tagged_docs(lang_items, tag_lang_items_item, |item_doc| {
let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id);
- let id = reader::doc_as_u32(id_doc) as uint;
+ let id = reader::doc_as_u32(id_doc) as usize;
let node_id_doc = reader::get_doc(item_doc,
tag_lang_items_item_node_id);
let node_id = reader::doc_as_u32(node_id_doc) as ast::NodeId;
let cratedoc = rbml::Doc::new(data);
let depsdoc = reader::get_doc(cratedoc, tag_crate_deps);
let mut crate_num = 1;
- fn docstr(doc: rbml::Doc, tag_: uint) -> String {
+ fn docstr(doc: rbml::Doc, tag_: usize) -> String {
let d = reader::get_doc(doc, tag_);
d.as_str_slice().to_string()
}
fn doc_generics<'tcx>(base_doc: rbml::Doc,
tcx: &ty::ctxt<'tcx>,
cdata: Cmd,
- tag: uint)
+ tag: usize)
-> ty::Generics<'tcx>
{
let doc = reader::get_doc(base_doc, tag);
let def_id = translate_def_id(cdata, def_id);
let doc = reader::get_doc(rp_doc, tag_region_param_def_space);
- let space = subst::ParamSpace::from_uint(reader::doc_as_u64(doc) as uint);
+ let space = subst::ParamSpace::from_uint(reader::doc_as_u64(doc) as usize);
let doc = reader::get_doc(rp_doc, tag_region_param_def_index);
let index = reader::doc_as_u64(doc) as u32;
fn doc_predicates<'tcx>(base_doc: rbml::Doc,
tcx: &ty::ctxt<'tcx>,
cdata: Cmd,
- tag: uint)
+ tag: usize)
-> ty::GenericPredicates<'tcx>
{
let doc = reader::get_doc(base_doc, tag);
let mut predicates = subst::VecPerParamSpace::empty();
reader::tagged_docs(doc, tag_predicate, |predicate_doc| {
let space_doc = reader::get_doc(predicate_doc, tag_predicate_space);
- let space = subst::ParamSpace::from_uint(reader::doc_as_u8(space_doc) as uint);
+ let space = subst::ParamSpace::from_uint(reader::doc_as_u8(space_doc) as usize);
let data_doc = reader::get_doc(predicate_doc, tag_predicate_data);
let data = parse_predicate_data(data_doc.data, data_doc.start, cdata.cnum, tcx,
use metadata::decoder;
use metadata::tyencode;
use middle::def;
-use middle::ty::{lookup_item_type};
+use middle::ty::lookup_item_type;
use middle::ty::{self, Ty};
use middle::stability;
use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
fn encode_trait_ref<'a, 'tcx>(rbml_w: &mut Encoder,
ecx: &EncodeContext<'a, 'tcx>,
trait_ref: &ty::TraitRef<'tcx>,
- tag: uint) {
+ tag: usize) {
let ty_str_ctxt = &tyencode::ctxt {
diag: ecx.diag,
ds: def_to_string,
ecx: &EncodeContext<'a, 'tcx>,
generics: &ty::Generics<'tcx>,
predicates: &ty::GenericPredicates<'tcx>,
- tag: uint)
+ tag: usize)
{
rbml_w.start_tag(tag);
fn encode_predicates<'a,'tcx>(rbml_w: &mut Encoder,
ecx: &EncodeContext<'a,'tcx>,
predicates: &ty::GenericPredicates<'tcx>,
- tag: uint)
+ tag: usize)
{
rbml_w.start_tag(tag);
encode_predicates_in_current_doc(rbml_w, ecx, predicates);
for elt in index {
let mut s = SipHasher::new();
elt.val.hash(&mut s);
- let h = s.finish() as uint;
+ let h = s.finish() as usize;
(&mut buckets[h % 256]).push(elt);
}
// RBML compacts the encoded bytes whenever appropriate,
// so there are some garbages left after the end of the data.
- let metalen = wr.seek(SeekFrom::Current(0)).unwrap() as uint;
+ let metalen = wr.seek(SeekFrom::Current(0)).unwrap() as usize;
let mut v = wr.into_inner();
v.truncate(metalen);
assert_eq!(v.len(), metalen);
//! no means all of the necessary details. Take a look at the rest of
//! metadata::loader or metadata::creader for all the juicy details!
-use back::archive::{METADATA_FILENAME};
+use back::archive::METADATA_FILENAME;
use back::svh::Svh;
use session::Session;
use session::search_paths::PathKind;
unsafe {
let buf = common::path2cstr(filename);
let mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf.as_ptr());
- if mb as int == 0 {
+ if mb as isize == 0 {
return Err(format!("error reading library: '{}'",
filename.display()))
}
let mut name_buf = ptr::null();
let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf);
let name = slice::from_raw_parts(name_buf as *const u8,
- name_len as uint).to_vec();
+ name_len as usize).to_vec();
let name = String::from_utf8(name).unwrap();
debug!("get_metadata_section: name {}", name);
if read_meta_section_name(is_osx) == name {
let cbuf = llvm::LLVMGetSectionContents(si.llsi);
- let csz = llvm::LLVMGetSectionSize(si.llsi) as uint;
+ let csz = llvm::LLVMGetSectionSize(si.llsi) as usize;
let cvbuf: *const u8 = cbuf as *const u8;
let vlen = encoder::metadata_encoding_version.len();
debug!("checking {} bytes of metadata-version stamp",
filename.display())));
}
- let cvbuf1 = cvbuf.offset(vlen as int);
+ let cvbuf1 = cvbuf.offset(vlen as isize);
debug!("inflating {} bytes of compressed metadata",
csz - vlen);
let bytes = slice::from_raw_parts(cvbuf1, csz - vlen);
for attr in &item.attrs {
let mut used = true;
match &attr.name()[..] {
- "phase" => {
- self.sess.span_err(attr.span, "#[phase] is deprecated");
- }
- "plugin" => {
- self.sess.span_err(attr.span, "#[plugin] on `extern crate` is deprecated");
- self.sess.fileline_help(attr.span, &format!("use a crate attribute instead, \
- i.e. #![plugin({})]",
- item.ident.as_str()));
- }
"macro_use" => {
let names = attr.meta_item_list();
if names.is_none() {
pub struct PState<'a, 'tcx: 'a> {
data: &'a [u8],
krate: ast::CrateNum,
- pos: uint,
+ pos: usize,
tcx: &'a ty::ctxt<'tcx>
}
}
pub fn parse_state_from_data<'a, 'tcx>(data: &'a [u8], crate_num: ast::CrateNum,
- pos: uint, tcx: &'a ty::ctxt<'tcx>)
+ pos: usize, tcx: &'a ty::ctxt<'tcx>)
-> PState<'a, 'tcx> {
PState {
data: data,
}
}
-fn data_log_string(data: &[u8], pos: uint) -> String {
+fn data_log_string(data: &[u8], pos: usize) -> String {
let mut buf = String::new();
buf.push_str("<<");
for i in pos..data.len() {
pub fn parse_ty_closure_data<'tcx, F>(data: &[u8],
crate_num: ast::CrateNum,
- pos: uint,
+ pos: usize,
tcx: &ty::ctxt<'tcx>,
conv: F)
-> ty::ClosureTy<'tcx> where
parse_closure_ty(&mut st, conv)
}
-pub fn parse_ty_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: uint,
+pub fn parse_ty_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: usize,
tcx: &ty::ctxt<'tcx>, conv: F) -> Ty<'tcx> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
{
parse_ty(&mut st, conv)
}
-pub fn parse_region_data<F>(data: &[u8], crate_num: ast::CrateNum, pos: uint, tcx: &ty::ctxt,
+pub fn parse_region_data<F>(data: &[u8], crate_num: ast::CrateNum, pos: usize, tcx: &ty::ctxt,
conv: F) -> ty::Region where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
{
parse_region(&mut st, conv)
}
-pub fn parse_bare_fn_ty_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: uint,
+pub fn parse_bare_fn_ty_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: usize,
tcx: &ty::ctxt<'tcx>, conv: F)
-> ty::BareFnTy<'tcx> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
parse_bare_fn_ty(&mut st, conv)
}
-pub fn parse_trait_ref_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: uint,
+pub fn parse_trait_ref_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: usize,
tcx: &ty::ctxt<'tcx>, conv: F)
-> Rc<ty::TraitRef<'tcx>> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
parse_trait_ref(&mut st, conv)
}
-pub fn parse_substs_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: uint,
+pub fn parse_substs_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum, pos: usize,
tcx: &ty::ctxt<'tcx>, conv: F) -> subst::Substs<'tcx> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
{
}
pub fn parse_bounds_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum,
- pos: uint, tcx: &ty::ctxt<'tcx>, conv: F)
+ pos: usize, tcx: &ty::ctxt<'tcx>, conv: F)
-> ty::ParamBounds<'tcx> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
{
}
pub fn parse_existential_bounds_data<'tcx, F>(data: &[u8], crate_num: ast::CrateNum,
- pos: uint, tcx: &ty::ctxt<'tcx>, conv: F)
+ pos: usize, tcx: &ty::ctxt<'tcx>, conv: F)
-> ty::ExistentialBounds<'tcx> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
{
}
pub fn parse_builtin_bounds_data<F>(data: &[u8], crate_num: ast::CrateNum,
- pos: uint, tcx: &ty::ctxt, conv: F)
+ pos: usize, tcx: &ty::ctxt, conv: F)
-> ty::BuiltinBounds where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
{
parse_builtin_bounds(&mut st, conv)
}
-fn parse_size(st: &mut PState) -> Option<uint> {
+fn parse_size(st: &mut PState) -> Option<usize> {
assert_eq!(next(st), '/');
if peek(st) == '|' {
let tcx = st.tcx;
match next(st) {
'b' => return tcx.types.bool,
- 'i' => { /* eat the s of is */ next(st); return tcx.types.int },
- 'u' => { /* eat the s of us */ next(st); return tcx.types.uint },
+ 'i' => { /* eat the s of is */ next(st); return tcx.types.isize },
+ 'u' => { /* eat the s of us */ next(st); return tcx.types.usize },
'M' => {
match next(st) {
'b' => return tcx.types.u8,
return (*conv)(source, scan(st, |c| { c == '|' }, parse_def_id));
}
-fn parse_uint(st: &mut PState) -> uint {
+fn parse_uint(st: &mut PState) -> usize {
let mut n = 0;
loop {
let cur = peek(st);
if cur < '0' || cur > '9' { return n; }
st.pos = st.pos + 1;
n *= 10;
- n += (cur as uint) - ('0' as uint);
+ n += (cur as usize) - ('0' as usize);
};
}
fn parse_u32(st: &mut PState) -> u32 {
let n = parse_uint(st);
let m = n as u32;
- assert_eq!(m as uint, n);
+ assert_eq!(m as usize, n);
m
}
subst::ParamSpace::from_uint(parse_uint(st))
}
-fn parse_hex(st: &mut PState) -> uint {
+fn parse_hex(st: &mut PState) -> usize {
let mut n = 0;
loop {
let cur = peek(st);
st.pos = st.pos + 1;
n *= 16;
if '0' <= cur && cur <= '9' {
- n += (cur as uint) - ('0' as uint);
- } else { n += 10 + (cur as uint) - ('a' as uint); }
+ n += (cur as usize) - ('0' as usize);
+ } else { n += 10 + (cur as usize) - ('a' as usize); }
};
}
let def_part = &buf[colon_idx + 1..len];
let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| {
- s.parse::<uint>().ok()
+ s.parse::<usize>().ok()
}) {
Some(cn) => cn as ast::CrateNum,
None => panic!("internal error: parse_def_id: crate number expected, found {:?}",
crate_part)
};
let def_num = match str::from_utf8(def_part).ok().and_then(|s| {
- s.parse::<uint>().ok()
+ s.parse::<usize>().ok()
}) {
Some(dn) => dn as ast::NodeId,
None => panic!("internal error: parse_def_id: id expected, found {:?}",
}
pub fn parse_predicate_data<'tcx, F>(data: &[u8],
- start: uint,
+ start: usize,
crate_num: ast::CrateNum,
tcx: &ty::ctxt<'tcx>,
conv: F)
}
}
-pub fn parse_type_param_def_data<'tcx, F>(data: &[u8], start: uint,
+pub fn parse_type_param_def_data<'tcx, F>(data: &[u8], start: usize,
crate_num: ast::CrateNum, tcx: &ty::ctxt<'tcx>,
conv: F) -> ty::TypeParameterDef<'tcx> where
F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
ty::ty_char => mywrite!(w, "c"),
ty::ty_int(t) => {
match t {
- ast::TyIs(_) => mywrite!(w, "is"),
+ ast::TyIs => mywrite!(w, "is"),
ast::TyI8 => mywrite!(w, "MB"),
ast::TyI16 => mywrite!(w, "MW"),
ast::TyI32 => mywrite!(w, "ML"),
}
ty::ty_uint(t) => {
match t {
- ast::TyUs(_) => mywrite!(w, "us"),
+ ast::TyUs => mywrite!(w, "us"),
ast::TyU8 => mywrite!(w, "Mb"),
ast::TyU16 => mywrite!(w, "Mw"),
ast::TyU32 => mywrite!(w, "Ml"),
use syntax::ast;
use util::ppaux::Repr;
-pub const NO_REGIONS: uint = 1;
-pub const NO_TPS: uint = 2;
+pub const NO_REGIONS: usize = 1;
+pub const NO_TPS: usize = 2;
-pub fn check_path_args(tcx: &ty::ctxt, segments: &[ast::PathSegment], flags: uint) {
+pub fn check_path_args(tcx: &ty::ctxt, segments: &[ast::PathSegment], flags: usize) {
for segment in segments {
if (flags & NO_TPS) != 0 {
for typ in segment.parameters.types() {
use rbml;
use serialize;
use serialize::{Decodable, Decoder, DecoderHelpers, Encodable};
-use serialize::{EncoderHelpers};
+use serialize::EncoderHelpers;
#[cfg(test)] use std::io::Cursor;
#[cfg(test)] use syntax::parse;
let ii = simplify_ast(ii);
let id_range = ast_util::compute_id_range_for_inlined_item(&ii);
- rbml_w.start_tag(c::tag_ast as uint);
+ rbml_w.start_tag(c::tag_ast as usize);
id_range.encode(rbml_w);
encode_ast(rbml_w, &ii);
encode_side_tables_for_ii(ecx, rbml_w, &ii);
// but eventually we should add entries to the local codemap as required.
fn encode_ast(rbml_w: &mut Encoder, item: &ast::InlinedItem) {
- rbml_w.start_tag(c::tag_tree as uint);
+ rbml_w.start_tag(c::tag_tree as usize);
item.encode(rbml_w);
rbml_w.end_tag();
}
}
fn decode_ast(par_doc: rbml::Doc) -> ast::InlinedItem {
- let chi_doc = par_doc.get(c::tag_tree as uint);
+ let chi_doc = par_doc.get(c::tag_tree as usize);
let mut d = reader::Decoder::new(chi_doc);
Decodable::decode(&mut d).unwrap()
}
f: F) where
F: FnOnce(&mut Encoder<'a>),
{
- self.start_tag(tag_id as uint);
+ self.start_tag(tag_id as usize);
f(self);
self.end_tag();
}
fn encode_side_tables_for_ii(ecx: &e::EncodeContext,
rbml_w: &mut Encoder,
ii: &ast::InlinedItem) {
- rbml_w.start_tag(c::tag_table as uint);
+ rbml_w.start_tag(c::tag_table as usize);
ast_util::visit_ids_for_inlined_item(ii, &mut SideTableEncodingIdVisitor {
ecx: ecx,
rbml_w: rbml_w
}
trait doc_decoder_helpers {
- fn as_int(&self) -> int;
+ fn as_int(&self) -> isize;
fn opt_child(&self, tag: c::astencode_tag) -> Option<Self>;
}
impl<'a> doc_decoder_helpers for rbml::Doc<'a> {
- fn as_int(&self) -> int { reader::doc_as_u64(*self) as int }
+ fn as_int(&self) -> isize { reader::doc_as_u64(*self) as isize }
fn opt_child(&self, tag: c::astencode_tag) -> Option<rbml::Doc<'a>> {
- reader::maybe_get_doc(*self, tag as uint)
+ reader::maybe_get_doc(*self, tag as usize)
}
}
this.read_enum_variant(variants, |this, i| {
Ok(match i {
0 => {
- let len: uint =
+ let len: usize =
this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap();
ty::UnsizeLength(len)
let uk: ty::UnsizeKind =
this.read_enum_variant_arg(0,
|this| Ok(this.read_unsize_kind(dcx))).unwrap();
- let idx: uint =
+ let idx: usize =
this.read_enum_variant_arg(1, |this| Decodable::decode(this)).unwrap();
ty::UnsizeStruct(box uk, idx)
fn decode_side_tables(dcx: &DecodeContext,
ast_doc: rbml::Doc) {
- let tbl_doc = ast_doc.get(c::tag_table as uint);
+ let tbl_doc = ast_doc.get(c::tag_table as usize);
reader::docs(tbl_doc, |tag, entry_doc| {
let mut entry_dsr = reader::Decoder::new(entry_doc);
let id0: ast::NodeId = Decodable::decode(&mut entry_dsr).unwrap();
#[cfg(test)]
fn encode_item_ast(rbml_w: &mut Encoder, item: &ast::Item) {
- rbml_w.start_tag(c::tag_tree as uint);
+ rbml_w.start_tag(c::tag_tree as usize);
(*item).encode(rbml_w);
rbml_w.end_tag();
}
#[cfg(test)]
fn decode_item_ast(par_doc: rbml::Doc) -> ast::Item {
- let chi_doc = par_doc.get(c::tag_tree as uint);
+ let chi_doc = par_doc.get(c::tag_tree as usize);
let mut d = reader::Decoder::new(chi_doc);
Decodable::decode(&mut d).unwrap()
}
fn test_smalltalk() {
let cx = mk_ctxt();
roundtrip(quote_item!(&cx,
- fn foo() -> int { 3 + 4 } // first smalltalk program ever executed.
+ fn foo() -> isize { 3 + 4 } // first smalltalk program ever executed.
));
}
*/
fn test_more() {
let cx = mk_ctxt();
roundtrip(quote_item!(&cx,
- fn foo(x: uint, y: uint) -> uint {
+ fn foo(x: usize, y: usize) -> usize {
let z = x + y;
return z;
}
fn test_simplification() {
let cx = mk_ctxt();
let item = quote_item!(&cx,
- fn new_int_alist<B>() -> alist<int, B> {
- fn eq_int(a: int, b: int) -> bool { a == b }
+ fn new_int_alist<B>() -> alist<isize, B> {
+ fn eq_int(a: isize, b: isize) -> bool { a == b }
return alist {eq_fn: eq_int, data: Vec::new()};
}
).unwrap();
let item_in = e::IIItemRef(&*item);
let item_out = simplify_ast(item_in);
let item_exp = ast::IIItem(quote_item!(&cx,
- fn new_int_alist<B>() -> alist<int, B> {
+ fn new_int_alist<B>() -> alist<isize, B> {
return alist {eq_fn: eq_int, data: Vec::new()};
}
).unwrap());
use middle::def::*;
use middle::expr_use_visitor::{ConsumeMode, Delegate, ExprUseVisitor, Init};
use middle::expr_use_visitor::{JustWrite, LoanCause, MutateMode};
-use middle::expr_use_visitor::{WriteAndRead};
+use middle::expr_use_visitor::WriteAndRead;
use middle::expr_use_visitor as euv;
use middle::mem_categorization::cmt;
use middle::pat_util::*;
let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0);
assert!(m.iter().all(|row| row.len() == column_count));
- let column_widths: Vec<uint> = (0..column_count).map(|col| {
+ let column_widths: Vec<usize> = (0..column_count).map(|col| {
pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0)
}).collect();
/// Ranges of literal values (2..5).
ConstantRange(const_val, const_val),
/// Array patterns of length n.
- Slice(uint),
+ Slice(usize),
/// Array patterns with a subslice.
- SliceWithSubslice(uint, uint)
+ SliceWithSubslice(usize, usize)
}
#[derive(Clone, PartialEq)]
/// left_ty: tuple of 3 elements
/// pats: [10, 20, _] => (10, 20, _)
///
-/// left_ty: struct X { a: (bool, &'static str), b: uint}
+/// left_ty: struct X { a: (bool, &'static str), b: usize}
/// pats: [(false, "foo"), 42] => X { a: (false, "foo"), b: 42 }
fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
pats: Vec<&Pat>, left_ty: Ty) -> P<Pat> {
}
fn missing_constructor(cx: &MatchCheckCtxt, &Matrix(ref rows): &Matrix,
- left_ty: Ty, max_slice_length: uint) -> Option<Constructor> {
+ left_ty: Ty, max_slice_length: usize) -> Option<Constructor> {
let used_constructors: Vec<Constructor> = rows.iter()
.flat_map(|row| pat_constructors(cx, row[0], left_ty, max_slice_length).into_iter())
.collect();
/// but is instead bounded by the maximum fixed length of slice patterns in
/// the column of patterns being analyzed.
fn all_constructors(cx: &MatchCheckCtxt, left_ty: Ty,
- max_slice_length: uint) -> Vec<Constructor> {
+ max_slice_length: usize) -> Vec<Constructor> {
match left_ty.sty {
ty::ty_bool =>
[true, false].iter().map(|b| ConstantValue(const_bool(*b))).collect(),
/// On the other hand, a wild pattern and an identifier pattern cannot be
/// specialized in any way.
fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
- left_ty: Ty, max_slice_length: uint) -> Vec<Constructor> {
+ left_ty: Ty, max_slice_length: usize) -> Vec<Constructor> {
let pat = raw_pat(p);
match pat.node {
ast::PatIdent(..) =>
///
/// For instance, a tuple pattern (_, 42, Some([])) has the arity of 3.
/// A struct pattern's arity is the number of fields it contains, etc.
-pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint {
+pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> usize {
match ty.sty {
ty::ty_tup(ref fs) => fs.len(),
ty::ty_uniq(_) => 1,
/// Structure patterns with a partial wild pattern (Foo { a: 42, .. }) have their missing
/// fields filled with wild patterns.
pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
- constructor: &Constructor, col: uint, arity: uint) -> Option<Vec<&'a Pat>> {
+ constructor: &Constructor, col: usize, arity: usize) -> Option<Vec<&'a Pat>> {
let &Pat {
id: pat_id, ref node, span: pat_span
} = raw_pat(r[col]);
CannotCastTo(s) => format!("can't cast this type to {}", s).into_cow(),
InvalidOpForBools(_) => "can't do this op on bools".into_cow(),
InvalidOpForFloats(_) => "can't do this op on floats".into_cow(),
- InvalidOpForIntUint(..) => "can't do this op on an int and uint".into_cow(),
- InvalidOpForUintInt(..) => "can't do this op on a uint and int".into_cow(),
+ InvalidOpForIntUint(..) => "can't do this op on an isize and usize".into_cow(),
+ InvalidOpForUintInt(..) => "can't do this op on a usize and isize".into_cow(),
NegateOnString => "negate on string".into_cow(),
NegateOnBoolean => "negate on boolean".into_cow(),
NegateOnBinary => "negate on binary literal".into_cow(),
}
ast::ExprBinary(op, ref a, ref b) => {
let b_ty = match op.node {
- ast::BiShl | ast::BiShr => Some(tcx.types.uint),
+ ast::BiShl | ast::BiShr => Some(tcx.types.usize),
_ => ety
};
match (try!(eval_const_expr_partial(tcx, &**a, ety)),
Some(&ty::ty_int(int_ty)) => int_ty,
_ => return false
};
- let int_ty = if let ast::TyIs(_) = int_ty {
+ let int_ty = if let ast::TyIs = int_ty {
tcx.sess.target.int_type
} else {
int_ty
ast::TyI16 => (a as i16) == i16::MIN,
ast::TyI32 => (a as i32) == i32::MIN,
ast::TyI64 => (a as i64) == i64::MIN,
- ast::TyIs(_) => unreachable!()
+ ast::TyIs => unreachable!()
}
};
match op.node {
ast::BiAnd | ast::BiBitAnd => const_int(a & b),
ast::BiOr | ast::BiBitOr => const_int(a | b),
ast::BiBitXor => const_int(a ^ b),
- ast::BiShl => const_int(a << b as uint),
- ast::BiShr => const_int(a >> b as uint),
+ ast::BiShl => const_int(a << b as usize),
+ ast::BiShr => const_int(a >> b as usize),
ast::BiEq => fromb(a == b),
ast::BiLt => fromb(a < b),
ast::BiLe => fromb(a <= b),
ast::BiAnd | ast::BiBitAnd => const_uint(a & b),
ast::BiOr | ast::BiBitOr => const_uint(a | b),
ast::BiBitXor => const_uint(a ^ b),
- ast::BiShl => const_uint(a << b as uint),
- ast::BiShr => const_uint(a >> b as uint),
+ ast::BiShl => const_uint(a << b as usize),
+ ast::BiShr => const_uint(a >> b as usize),
ast::BiEq => fromb(a == b),
ast::BiLt => fromb(a < b),
ast::BiLe => fromb(a <= b),
// shifts can have any integral type as their rhs
(const_int(a), const_uint(b)) => {
match op.node {
- ast::BiShl => const_int(a << b as uint),
- ast::BiShr => const_int(a >> b as uint),
+ ast::BiShl => const_int(a << b as usize),
+ ast::BiShr => const_int(a >> b as usize),
_ => signal!(e, InvalidOpForIntUint(op.node)),
}
}
(const_uint(a), const_int(b)) => {
match op.node {
- ast::BiShl => const_uint(a << b as uint),
- ast::BiShr => const_uint(a >> b as uint),
+ ast::BiShl => const_uint(a << b as usize),
+ ast::BiShr => const_uint(a >> b as usize),
_ => signal!(e, InvalidOpForUintInt(op.node)),
}
}
}
define_casts!{
- ty::ty_int(ast::TyIs(_)) => (int, const_int, i64),
+ ty::ty_int(ast::TyIs) => (isize, const_int, i64),
ty::ty_int(ast::TyI8) => (i8, const_int, i64),
ty::ty_int(ast::TyI16) => (i16, const_int, i64),
ty::ty_int(ast::TyI32) => (i32, const_int, i64),
ty::ty_int(ast::TyI64) => (i64, const_int, i64),
- ty::ty_uint(ast::TyUs(_)) => (uint, const_uint, u64),
+ ty::ty_uint(ast::TyUs) => (usize, const_uint, u64),
ty::ty_uint(ast::TyU8) => (u8, const_uint, u64),
ty::ty_uint(ast::TyU16) => (u16, const_uint, u64),
ty::ty_uint(ast::TyU32) => (u32, const_uint, u64),
oper: O,
/// number of bits to propagate per id
- bits_per_id: uint,
+ bits_per_id: usize,
/// number of words we will use to store bits_per_id.
/// equal to bits_per_id/usize::BITS rounded up.
- words_per_id: uint,
+ words_per_id: usize,
// mapping from node to cfg node index
// FIXME (#6298): Shouldn't this go with CFG?
// the full vector (see the method `compute_id_range()`).
/// bits generated as we exit the cfg node. Updated by `add_gen()`.
- gens: Vec<uint>,
+ gens: Vec<usize>,
/// bits killed as we exit the cfg node. Updated by `add_kill()`.
- kills: Vec<uint>,
+ kills: Vec<usize>,
/// bits that are valid on entry to the cfg node. Updated by
/// `propagate()`.
- on_entry: Vec<uint>,
+ on_entry: Vec<usize>,
}
pub trait BitwiseOperator {
/// Joins two predecessor bits together, typically either `|` or `&`
- fn join(&self, succ: uint, pred: uint) -> uint;
+ fn join(&self, succ: usize, pred: usize) -> usize;
}
/// Parameterization for the precise form of data flow that is used.
cfg: &cfg::CFG,
oper: O,
id_range: IdRange,
- bits_per_id: uint) -> DataFlowContext<'a, 'tcx, O> {
+ bits_per_id: usize) -> DataFlowContext<'a, 'tcx, O> {
let words_per_id = (bits_per_id + usize::BITS as usize - 1) / usize::BITS as usize;
let num_nodes = cfg.graph.all_nodes().len();
}
}
- pub fn add_gen(&mut self, id: ast::NodeId, bit: uint) {
+ pub fn add_gen(&mut self, id: ast::NodeId, bit: usize) {
//! Indicates that `id` generates `bit`
debug!("{} add_gen(id={}, bit={})",
self.analysis_name, id, bit);
}
}
- pub fn add_kill(&mut self, id: ast::NodeId, bit: uint) {
+ pub fn add_kill(&mut self, id: ast::NodeId, bit: usize) {
//! Indicates that `id` kills `bit`
debug!("{} add_kill(id={}, bit={})",
self.analysis_name, id, bit);
}
}
- fn apply_gen_kill(&self, cfgidx: CFGIndex, bits: &mut [uint]) {
+ fn apply_gen_kill(&self, cfgidx: CFGIndex, bits: &mut [usize]) {
//! Applies the gen and kill sets for `cfgidx` to `bits`
debug!("{} apply_gen_kill(cfgidx={:?}, bits={}) [before]",
self.analysis_name, cfgidx, mut_bits_to_string(bits));
self.analysis_name, cfgidx, mut_bits_to_string(bits));
}
- fn compute_id_range(&self, cfgidx: CFGIndex) -> (uint, uint) {
+ fn compute_id_range(&self, cfgidx: CFGIndex) -> (usize, usize) {
let n = cfgidx.node_id();
let start = n * self.words_per_id;
let end = start + self.words_per_id;
pub fn each_bit_on_entry<F>(&self, id: ast::NodeId, mut f: F) -> bool where
- F: FnMut(uint) -> bool,
+ F: FnMut(usize) -> bool,
{
//! Iterates through each bit that is set on entry to `id`.
//! Only useful after `propagate()` has been called.
}
pub fn each_bit_for_node<F>(&self, e: EntryOrExit, cfgidx: CFGIndex, f: F) -> bool where
- F: FnMut(uint) -> bool,
+ F: FnMut(usize) -> bool,
{
//! Iterates through each bit that is set on entry/exit to `cfgidx`.
//! Only useful after `propagate()` has been called.
}
pub fn each_gen_bit<F>(&self, id: ast::NodeId, mut f: F) -> bool where
- F: FnMut(uint) -> bool,
+ F: FnMut(usize) -> bool,
{
//! Iterates through each bit in the gen set for `id`.
if !self.has_bitset_for_nodeid(id) {
return true;
}
- fn each_bit<F>(&self, words: &[uint], mut f: F) -> bool where
- F: FnMut(uint) -> bool,
+ fn each_bit<F>(&self, words: &[usize], mut f: F) -> bool where
+ F: FnMut(usize) -> bool,
{
//! Helper for iterating over the bits in a bit set.
//! Returns false on the first call to `f` that returns false;
impl<'a, 'b, 'tcx, O:DataFlowOperator> PropagationContext<'a, 'b, 'tcx, O> {
fn walk_cfg(&mut self,
cfg: &cfg::CFG,
- in_out: &mut [uint]) {
+ in_out: &mut [usize]) {
debug!("DataFlowContext::walk_cfg(in_out={}) {}",
bits_to_string(in_out), self.dfcx.analysis_name);
assert!(self.dfcx.bits_per_id > 0);
});
}
- fn reset(&mut self, bits: &mut [uint]) {
+ fn reset(&mut self, bits: &mut [usize]) {
let e = if self.dfcx.oper.initial_value() {usize::MAX} else {0};
for b in bits {
*b = e;
}
fn propagate_bits_into_graph_successors_of(&mut self,
- pred_bits: &[uint],
+ pred_bits: &[usize],
cfg: &cfg::CFG,
cfgidx: CFGIndex) {
cfg.graph.each_outgoing_edge(cfgidx, |_e_idx, edge| {
}
fn propagate_bits_into_entry_set_for(&mut self,
- pred_bits: &[uint],
+ pred_bits: &[usize],
edge: &cfg::CFGEdge) {
let source = edge.source();
let cfgidx = edge.target();
}
}
-fn mut_bits_to_string(words: &mut [uint]) -> String {
+fn mut_bits_to_string(words: &mut [usize]) -> String {
bits_to_string(words)
}
-fn bits_to_string(words: &[uint]) -> String {
+fn bits_to_string(words: &[usize]) -> String {
let mut result = String::new();
let mut sep = '[';
}
#[inline]
-fn bitwise<Op:BitwiseOperator>(out_vec: &mut [uint],
- in_vec: &[uint],
+fn bitwise<Op:BitwiseOperator>(out_vec: &mut [usize],
+ in_vec: &[usize],
op: &Op) -> bool {
assert_eq!(out_vec.len(), in_vec.len());
let mut changed = false;
changed
}
-fn set_bit(words: &mut [uint], bit: uint) -> bool {
+fn set_bit(words: &mut [usize], bit: usize) -> bool {
debug!("set_bit: words={} bit={}",
mut_bits_to_string(words), bit_str(bit));
let word = bit / usize::BITS as usize;
oldv != newv
}
-fn bit_str(bit: uint) -> String {
+fn bit_str(bit: usize) -> String {
let byte = bit >> 8;
let lobits = 1 << (bit & 0xFF);
format!("[{}:{}-{:02x}]", bit, byte, lobits)
struct Union;
impl BitwiseOperator for Union {
- fn join(&self, a: uint, b: uint) -> uint { a | b }
+ fn join(&self, a: usize, b: usize) -> usize { a | b }
}
struct Subtract;
impl BitwiseOperator for Subtract {
- fn join(&self, a: uint, b: uint) -> uint { a & !b }
+ fn join(&self, a: usize, b: usize) -> usize { a & !b }
}
}
}
- fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: uint) {
+ fn handle_tup_field_access(&mut self, lhs: &ast::Expr, idx: usize) {
match ty::expr_ty_adjusted(self.tcx, lhs).sty {
ty::ty_struct(id, _) => {
let fields = ty::lookup_struct_fields(self.tcx, id);
assert!(src.rlib.is_some());
debug!("adding staticlib: {}", data.name);
add_library(sess, cnum, cstore::RequireStatic, &mut formats);
- ret[cnum as uint - 1] = Some(cstore::RequireStatic);
+ ret[cnum as usize - 1] = Some(cstore::RequireStatic);
}
});
/// `deref()` is declared with `&self`, this is an autoref of `x`.
fn walk_autoderefs(&mut self,
expr: &ast::Expr,
- autoderefs: uint) {
+ autoderefs: usize) {
debug!("walk_autoderefs expr={} autoderefs={}", expr.repr(self.tcx()), autoderefs);
for i in 0..autoderefs {
fn walk_autoref(&mut self,
expr: &ast::Expr,
autoref: &ty::AutoRef,
- n: uint) {
+ n: usize) {
debug!("walk_autoref expr={}", expr.repr(self.tcx()));
match *autoref {
}
}
+ // When this returns true, it means that the expression *is* a
+ // method-call (i.e. via the operator-overload). This true result
+ // also implies that walk_overloaded_operator already took care of
+ // recursively processing the input arguments, and thus the caller
+ // should not do so.
fn walk_overloaded_operator(&mut self,
expr: &ast::Expr,
receiver: &ast::Expr,
StrSimplifiedType,
VecSimplifiedType,
PtrSimplifiedType,
- TupleSimplifiedType(uint),
+ TupleSimplifiedType(usize),
TraitSimplifiedType(ast::DefId),
StructSimplifiedType(ast::DefId),
ClosureSimplifiedType(ast::DefId),
- FunctionSimplifiedType(uint),
+ FunctionSimplifiedType(usize),
ParameterSimplifiedType,
}
}
#[derive(Clone, Copy, PartialEq, Debug)]
-pub struct NodeIndex(pub uint);
+pub struct NodeIndex(pub usize);
#[allow(non_upper_case_globals)]
pub const InvalidNodeIndex: NodeIndex = NodeIndex(usize::MAX);
#[derive(Copy, PartialEq, Debug)]
-pub struct EdgeIndex(pub uint);
+pub struct EdgeIndex(pub usize);
#[allow(non_upper_case_globals)]
pub const InvalidEdgeIndex: EdgeIndex = EdgeIndex(usize::MAX);
// Use a private field here to guarantee no more instances are created:
#[derive(Copy, Debug)]
-pub struct Direction { repr: uint }
+pub struct Direction { repr: usize }
#[allow(non_upper_case_globals)]
pub const Outgoing: Direction = Direction { repr: 0 };
#[allow(non_upper_case_globals)]
pub const Incoming: Direction = Direction { repr: 1 };
impl NodeIndex {
- fn get(&self) -> uint { let NodeIndex(v) = *self; v }
+ fn get(&self) -> usize { let NodeIndex(v) = *self; v }
/// Returns unique id (unique with respect to the graph holding associated node).
- pub fn node_id(&self) -> uint { self.get() }
+ pub fn node_id(&self) -> usize { self.get() }
}
impl EdgeIndex {
- fn get(&self) -> uint { let EdgeIndex(v) = *self; v }
+ fn get(&self) -> usize { let EdgeIndex(v) = *self; v }
/// Returns unique id (unique with respect to the graph holding associated edge).
- pub fn edge_id(&self) -> uint { self.get() }
+ pub fn edge_id(&self) -> usize { self.get() }
}
impl<N,E> Graph<N,E> {
}
}
- pub fn with_capacity(num_nodes: uint,
- num_edges: uint) -> Graph<N,E> {
+ pub fn with_capacity(num_nodes: usize,
+ num_edges: usize) -> Graph<N,E> {
Graph {
nodes: Vec::with_capacity(num_nodes),
edges: Vec::with_capacity(num_edges),
// computation.
pub fn iterate_until_fixed_point<'a, F>(&'a self, mut op: F) where
- F: FnMut(uint, EdgeIndex, &'a Edge<E>) -> bool,
+ F: FnMut(usize, EdgeIndex, &'a Edge<E>) -> bool,
{
let mut iteration = 0;
let mut changed = true;
//! In particular, it might be enough to say (A,B) are bivariant for
//! all (A,B).
-use middle::ty::{BuiltinBounds};
+use middle::ty::BuiltinBounds;
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::infer::combine::*;
-use middle::infer::{cres};
-use middle::infer::type_variable::{BiTo};
-use util::ppaux::{Repr};
+use middle::infer::cres;
+use middle::infer::type_variable::BiTo;
+use util::ppaux::Repr;
pub struct Bivariate<'f, 'tcx: 'f> {
fields: CombineFields<'f, 'tcx>
use middle::subst::{ErasedRegions, NonerasedRegions, Substs};
use middle::ty::{FloatVar, FnSig, IntVar, TyVar};
use middle::ty::{IntType, UintType};
-use middle::ty::{BuiltinBounds};
+use middle::ty::BuiltinBounds;
use middle::ty::{self, Ty};
use middle::ty_fold;
use middle::ty_fold::{TypeFolder, TypeFoldable};
use middle::ty::{self, Ty};
use middle::ty::TyVar;
use middle::infer::combine::*;
-use middle::infer::{cres};
-use middle::infer::{Subtype};
-use middle::infer::type_variable::{EqTo};
-use util::ppaux::{Repr};
+use middle::infer::cres;
+use middle::infer::Subtype;
+use middle::infer::type_variable::EqTo;
+use util::ppaux::Repr;
pub struct Equate<'f, 'tcx: 'f> {
fields: CombineFields<'f, 'tcx>
// LifeGiver is responsible for generating fresh lifetime names
struct LifeGiver {
taken: HashSet<String>,
- counter: Cell<uint>,
+ counter: Cell<usize>,
generated: RefCell<Vec<ast::Lifetime>>,
}
return lifetime;
// 0 .. 25 generates a .. z, 26 .. 51 generates aa .. zz, and so on
- fn num_to_string(counter: uint) -> String {
+ fn num_to_string(counter: usize) -> String {
let mut s = String::new();
let (n, r) = (counter/26 + 1, counter % 26);
let letter: char = from_u32((r+97) as u32).unwrap();
use super::combine::*;
use super::lattice::*;
use super::higher_ranked::HigherRankedRelations;
-use super::{cres};
+use super::cres;
use super::Subtype;
use middle::ty::{self, Ty};
use super::glb::Glb;
use super::lub::Lub;
-use middle::ty::{TyVar};
+use middle::ty::TyVar;
use middle::ty::{self, Ty};
use util::ppaux::Repr;
use super::combine::*;
use super::higher_ranked::HigherRankedRelations;
use super::lattice::*;
-use super::{cres};
-use super::{Subtype};
+use super::cres;
+use super::Subtype;
use middle::ty::{self, Ty};
use util::ppaux::Repr;
use middle::ty::replace_late_bound_regions;
use middle::ty::{self, Ty};
use middle::ty_fold::{TypeFolder, TypeFoldable};
-use std::cell::{RefCell};
+use std::cell::RefCell;
use std::fmt;
use std::rc::Rc;
use syntax::ast;
use syntax::codemap;
use syntax::codemap::Span;
use util::nodemap::FnvHashMap;
-use util::ppaux::{ty_to_string};
+use util::ppaux::ty_to_string;
use util::ppaux::{Repr, UserString};
use self::combine::{Combine, Combineable, CombineFields};
ty::mk_var(self.tcx, self.next_ty_var_id(true))
}
- pub fn next_ty_vars(&self, n: uint) -> Vec<Ty<'tcx>> {
+ pub fn next_ty_vars(&self, n: usize) -> Vec<Ty<'tcx>> {
(0..n).map(|_i| self.next_ty_var()).collect()
}
tcx: &'a ty::ctxt<'tcx>,
graph_name: String,
map: &'a FnvHashMap<Constraint, SubregionOrigin<'tcx>>,
- node_ids: FnvHashMap<Node, uint>,
+ node_ids: FnvHashMap<Node, usize>,
}
#[derive(Clone, Hash, PartialEq, Eq, Debug, Copy)]
CommitedSnapshot,
AddVar(RegionVid),
AddConstraint(Constraint),
- AddVerify(uint),
+ AddVerify(usize),
AddGiven(ty::FreeRegion, ty::RegionVid),
AddCombination(CombineMapType, TwoRegions)
}
#[derive(Debug)]
pub struct RegionSnapshot {
- length: uint,
+ length: usize,
skolemization_count: u32,
}
AddVar(vid) => {
let mut var_origins = self.var_origins.borrow_mut();
var_origins.pop().unwrap();
- assert_eq!(var_origins.len(), vid.index as uint);
+ assert_eq!(var_origins.len(), vid.index as usize);
}
AddConstraint(ref constraint) => {
self.constraints.borrow_mut().remove(constraint);
pub fn num_vars(&self) -> u32 {
let len = self.var_origins.borrow().len();
// enforce no overflow
- assert!(len as u32 as uint == len);
+ assert!(len as u32 as usize == len);
len as u32
}
match *self.values.borrow() {
None => {
self.tcx.sess.span_bug(
- (*self.var_origins.borrow())[rid.index as uint].span(),
+ (*self.var_origins.borrow())[rid.index as usize].span(),
"attempt to resolve region variable before values have \
been computed!")
}
let mut result_set = vec!(r0);
let mut result_index = 0;
while result_index < result_set.len() {
- // nb: can't use uint::range() here because result_set grows
+ // nb: can't use usize::range() here because result_set grows
let r = result_set[result_index];
debug!("result_index={}, r={:?}", result_index, r);
(ReInfer(ReVar(v_id)), _) | (_, ReInfer(ReVar(v_id))) => {
self.tcx.sess.span_bug(
- (*self.var_origins.borrow())[v_id.index as uint].span(),
+ (*self.var_origins.borrow())[v_id.index as usize].span(),
&format!("lub_concrete_regions invoked with \
non-concrete regions: {:?}, {:?}",
a,
(ReInfer(ReVar(v_id)), _) |
(_, ReInfer(ReVar(v_id))) => {
self.tcx.sess.span_bug(
- (*self.var_origins.borrow())[v_id.index as uint].span(),
+ (*self.var_origins.borrow())[v_id.index as usize].span(),
&format!("glb_concrete_regions invoked with \
non-concrete regions: {:?}, {:?}",
a,
}
fn construct_var_data(&self) -> Vec<VarData> {
- (0..self.num_vars() as uint).map(|_| {
+ (0..self.num_vars() as usize).map(|_| {
VarData {
// All nodes are initially classified as contracting; during
// the expansion phase, we will shift the classification for
.repr(self.tcx));
match *constraint {
ConstrainRegSubVar(a_region, b_vid) => {
- let b_data = &mut var_data[b_vid.index as uint];
+ let b_data = &mut var_data[b_vid.index as usize];
self.expand_node(a_region, b_vid, b_data)
}
ConstrainVarSubVar(a_vid, b_vid) => {
- match var_data[a_vid.index as uint].value {
+ match var_data[a_vid.index as usize].value {
NoValue | ErrorValue => false,
Value(a_region) => {
- let b_node = &mut var_data[b_vid.index as uint];
+ let b_node = &mut var_data[b_vid.index as usize];
self.expand_node(a_region, b_vid, b_node)
}
}
false
}
ConstrainVarSubVar(a_vid, b_vid) => {
- match var_data[b_vid.index as uint].value {
+ match var_data[b_vid.index as usize].value {
NoValue | ErrorValue => false,
Value(b_region) => {
- let a_data = &mut var_data[a_vid.index as uint];
+ let a_data = &mut var_data[a_vid.index as usize];
self.contract_node(a_vid, a_data, b_region)
}
}
}
ConstrainVarSubReg(a_vid, b_region) => {
- let a_data = &mut var_data[a_vid.index as uint];
+ let a_data = &mut var_data[a_vid.index as usize];
self.contract_node(a_vid, a_data, b_region)
}
}
// idea is to report errors that derive from independent
// regions of the graph, but not those that derive from
// overlapping locations.
- let mut dup_vec: Vec<_> = repeat(u32::MAX).take(self.num_vars() as uint).collect();
+ let mut dup_vec: Vec<_> = repeat(u32::MAX).take(self.num_vars() as usize).collect();
let mut opt_graph = None;
- for idx in 0..self.num_vars() as uint {
+ for idx in 0..self.num_vars() as usize {
match var_data[idx].value {
Value(_) => {
/* Inference successful */
}
}
- (0..self.num_vars() as uint).map(|idx| var_data[idx].value).collect()
+ (0..self.num_vars() as usize).map(|idx| var_data[idx].value).collect()
}
fn construct_graph(&self) -> RegionGraph {
let constraints = self.constraints.borrow();
let num_edges = constraints.len();
- let mut graph = graph::Graph::with_capacity(num_vars as uint + 1,
+ let mut graph = graph::Graph::with_capacity(num_vars as usize + 1,
num_edges);
for _ in 0..num_vars {
for (constraint, _) in &*constraints {
match *constraint {
ConstrainVarSubVar(a_id, b_id) => {
- graph.add_edge(NodeIndex(a_id.index as uint),
- NodeIndex(b_id.index as uint),
+ graph.add_edge(NodeIndex(a_id.index as usize),
+ NodeIndex(b_id.index as usize),
*constraint);
}
ConstrainRegSubVar(_, b_id) => {
graph.add_edge(dummy_idx,
- NodeIndex(b_id.index as uint),
+ NodeIndex(b_id.index as usize),
*constraint);
}
ConstrainVarSubReg(a_id, _) => {
- graph.add_edge(NodeIndex(a_id.index as uint),
+ graph.add_edge(NodeIndex(a_id.index as usize),
dummy_idx,
*constraint);
}
debug!("pushing SubSupConflict sub: {:?} sup: {:?}",
lower_bound.region, upper_bound.region);
errors.push(SubSupConflict(
- (*self.var_origins.borrow())[node_idx.index as uint].clone(),
+ (*self.var_origins.borrow())[node_idx.index as usize].clone(),
lower_bound.origin.clone(),
lower_bound.region,
upper_bound.origin.clone(),
}
self.tcx.sess.span_bug(
- (*self.var_origins.borrow())[node_idx.index as uint].span(),
+ (*self.var_origins.borrow())[node_idx.index as usize].span(),
&format!("collect_error_for_expanding_node() could not find error \
for var {:?}, lower_bounds={}, upper_bounds={}",
node_idx,
Ok(_) => {}
Err(_) => {
errors.push(SupSupConflict(
- (*self.var_origins.borrow())[node_idx.index as uint].clone(),
+ (*self.var_origins.borrow())[node_idx.index as usize].clone(),
upper_bound_1.origin.clone(),
upper_bound_1.region,
upper_bound_2.origin.clone(),
}
self.tcx.sess.span_bug(
- (*self.var_origins.borrow())[node_idx.index as uint].span(),
+ (*self.var_origins.borrow())[node_idx.index as usize].span(),
&format!("collect_error_for_contracting_node() could not find error \
for var {:?}, upper_bounds={}",
node_idx,
while !state.stack.is_empty() {
let node_idx = state.stack.pop().unwrap();
- let classification = var_data[node_idx.index as uint].classification;
+ let classification = var_data[node_idx.index as usize].classification;
// check whether we've visited this node on some previous walk
- if dup_vec[node_idx.index as uint] == u32::MAX {
- dup_vec[node_idx.index as uint] = orig_node_idx.index;
- } else if dup_vec[node_idx.index as uint] != orig_node_idx.index {
+ if dup_vec[node_idx.index as usize] == u32::MAX {
+ dup_vec[node_idx.index as usize] = orig_node_idx.index;
+ } else if dup_vec[node_idx.index as usize] != orig_node_idx.index {
state.dup_found = true;
}
dir: Direction) {
debug!("process_edges(source_vid={:?}, dir={:?})", source_vid, dir);
- let source_node_index = NodeIndex(source_vid.index as uint);
+ let source_node_index = NodeIndex(source_vid.index as usize);
graph.each_adjacent_edge(source_node_index, dir, |_, edge| {
match edge.data {
ConstrainVarSubVar(from_vid, to_vid) => {
}
fn lookup(values: &Vec<VarValue>, rid: ty::RegionVid) -> ty::Region {
- match values[rid.index as uint] {
+ match values[rid.index as usize] {
Value(r) => r,
NoValue => ReEmpty, // No constraints, return ty::ReEmpty
ErrorValue => ReStatic, // Previously reported error.
// except according to those terms.
use super::combine::*;
-use super::{cres};
+use super::cres;
use super::higher_ranked::HigherRankedRelations;
-use super::{Subtype};
+use super::Subtype;
use super::type_variable::{SubtypeOf, SupertypeOf};
use middle::ty::{self, Ty};
use middle::ty::TyVar;
-use util::ppaux::{Repr};
+use util::ppaux::Repr;
/// "Greatest lower bound" (common subtype)
pub struct Sub<'f, 'tcx: 'f> {
}
fn relations<'a>(&'a mut self, a: ty::TyVid) -> &'a mut Vec<Relation> {
- relations(self.values.get_mut(a.index as uint))
+ relations(self.values.get_mut(a.index as usize))
}
pub fn var_diverges<'a>(&'a self, vid: ty::TyVid) -> bool {
- self.values.get(vid.index as uint).diverging
+ self.values.get(vid.index as usize).diverging
}
/// Records that `a <: b`, `a :> b`, or `a == b`, depending on `dir`.
stack: &mut Vec<(Ty<'tcx>, RelationDir, ty::TyVid)>)
{
let old_value = {
- let value_ptr = &mut self.values.get_mut(vid.index as uint).value;
+ let value_ptr = &mut self.values.get_mut(vid.index as usize).value;
mem::replace(value_ptr, Known(ty))
};
}
pub fn probe(&self, vid: ty::TyVid) -> Option<Ty<'tcx>> {
- match self.values.get(vid.index as uint).value {
+ match self.values.get(vid.index as usize).value {
Bounded(..) => None,
Known(t) => Some(t)
}
action: UndoEntry) {
match action {
SpecifyVar(vid, relations) => {
- values[vid.index as uint].value = Bounded(relations);
+ values[vid.index as usize].value = Bounded(relations);
}
Relate(a, b) => {
- relations(&mut (*values)[a.index as uint]).pop();
- relations(&mut (*values)[b.index as uint]).pop();
+ relations(&mut (*values)[a.index as usize]).pop();
+ relations(&mut (*values)[b.index as usize]).pop();
}
}
}
pub trait UnifyKey : Clone + Debug + PartialEq {
type Value : UnifyValue;
- fn index(&self) -> uint;
+ fn index(&self) -> usize;
- fn from_index(u: uint) -> Self;
+ fn from_index(u: usize) -> Self;
// Given an inference context, returns the unification table
// appropriate to this key type.
#[derive(PartialEq,Clone,Debug)]
pub enum VarValue<K:UnifyKey> {
Redirect(K),
- Root(K::Value, uint),
+ Root(K::Value, usize),
}
/// Table of unification keys and their values.
pub struct Node<K:UnifyKey> {
pub key: K,
pub value: K::Value,
- pub rank: uint,
+ pub rank: usize,
}
#[derive(Copy)]
tcx: &ty::ctxt<'tcx>,
node_a: &Node<K>,
node_b: &Node<K>)
- -> (K, uint)
+ -> (K, usize)
{
debug!("unify(node_a(id={:?}, rank={:?}), node_b(id={:?}, rank={:?}))",
node_a.key,
impl UnifyKey for ty::IntVid {
type Value = Option<IntVarValue>;
- fn index(&self) -> uint { self.index as uint }
+ fn index(&self) -> usize { self.index as usize }
- fn from_index(i: uint) -> ty::IntVid { ty::IntVid { index: i as u32 } }
+ fn from_index(i: usize) -> ty::IntVid { ty::IntVid { index: i as u32 } }
fn unification_table<'v>(infcx: &'v InferCtxt) -> &'v RefCell<UnificationTable<ty::IntVid>> {
return &infcx.int_unification_table;
impl UnifyKey for ty::FloatVid {
type Value = Option<ast::FloatTy>;
- fn index(&self) -> uint { self.index as uint }
+ fn index(&self) -> usize { self.index as usize }
- fn from_index(i: uint) -> ty::FloatVid { ty::FloatVid { index: i as u32 } }
+ fn from_index(i: usize) -> ty::FloatVid { ty::FloatVid { index: i as u32 } }
fn unification_table<'v>(infcx: &'v InferCtxt) -> &'v RefCell<UnificationTable<ty::FloatVid>> {
return &infcx.float_unification_table;
let mut visitor = IntrinsicCheckingVisitor {
tcx: tcx,
param_envs: Vec::new(),
- dummy_sized_ty: tcx.types.int,
- dummy_unsized_ty: ty::mk_vec(tcx, tcx.types.int, None),
+ dummy_sized_ty: tcx.types.isize,
+ dummy_unsized_ty: ty::mk_vec(tcx, tcx.types.isize, None),
};
visit::walk_crate(&mut visitor, tcx.map.krate());
}
self.items.iter().enumerate()
}
- pub fn item_name(index: uint) -> &'static str {
+ pub fn item_name(index: usize) -> &'static str {
let item: Option<LangItem> = FromPrimitive::from_usize(index);
match item {
$( Some($variant) => $name, )*
}
pub fn require(&self, it: LangItem) -> Result<ast::DefId, String> {
- match self.items[it as uint] {
+ match self.items[it as usize] {
Some(id) => Ok(id),
None => {
Err(format!("requires `{}` lang_item",
- LanguageItems::item_name(it as uint)))
+ LanguageItems::item_name(it as usize)))
}
}
}
$(
#[allow(dead_code)]
pub fn $method(&self) -> Option<ast::DefId> {
- self.items[$variant as uint]
+ self.items[$variant as usize]
}
)*
}
session: &'a Session,
- item_refs: FnvHashMap<&'static str, uint>,
+ item_refs: FnvHashMap<&'static str, usize>,
}
impl<'a, 'v> Visitor<'v> for LanguageItemCollector<'a> {
pub fn new(session: &'a Session) -> LanguageItemCollector<'a> {
let mut item_refs = FnvHashMap();
- $( item_refs.insert($name, $variant as uint); )*
+ $( item_refs.insert($name, $variant as usize); )*
LanguageItemCollector {
session: session,
}
}
- pub fn collect_item(&mut self, item_index: uint,
+ pub fn collect_item(&mut self, item_index: usize,
item_def_id: ast::DefId, span: Span) {
// Check for duplicates.
match self.items.items[item_index] {
pub use self::deref_kind::*;
pub use self::categorization::*;
+use self::Aliasability::*;
+
use middle::check_const;
use middle::def;
use middle::region;
use middle::ty::{self, Ty};
-use util::nodemap::{NodeMap};
+use util::nodemap::NodeMap;
use util::ppaux::{Repr, UserString};
use syntax::ast::{MutImmutable, MutMutable};
cat_static_item,
cat_upvar(Upvar), // upvar referenced by closure env
cat_local(ast::NodeId), // local variable
- cat_deref(cmt<'tcx>, uint, PointerKind), // deref of a ptr
+ cat_deref(cmt<'tcx>, usize, PointerKind), // deref of a ptr
cat_interior(cmt<'tcx>, InteriorKind), // something interior: field, tuple, etc
cat_downcast(cmt<'tcx>, ast::DefId), // selects a particular enum variant (*1)
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum FieldName {
NamedField(ast::Name),
- PositionalField(uint)
+ PositionalField(usize)
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
impl MutabilityCategory {
pub fn from_mutbl(m: ast::Mutability) -> MutabilityCategory {
- match m {
+ let ret = match m {
MutImmutable => McImmutable,
MutMutable => McDeclared
- }
+ };
+ debug!("MutabilityCategory::{}({:?}) => {:?}",
+ "from_mutbl", m, ret);
+ ret
}
pub fn from_borrow_kind(borrow_kind: ty::BorrowKind) -> MutabilityCategory {
- match borrow_kind {
+ let ret = match borrow_kind {
ty::ImmBorrow => McImmutable,
ty::UniqueImmBorrow => McImmutable,
ty::MutBorrow => McDeclared,
- }
+ };
+ debug!("MutabilityCategory::{}({:?}) => {:?}",
+ "from_borrow_kind", borrow_kind, ret);
+ ret
}
- pub fn from_pointer_kind(base_mutbl: MutabilityCategory,
- ptr: PointerKind) -> MutabilityCategory {
- match ptr {
+ fn from_pointer_kind(base_mutbl: MutabilityCategory,
+ ptr: PointerKind) -> MutabilityCategory {
+ let ret = match ptr {
Unique => {
base_mutbl.inherit()
}
UnsafePtr(m) => {
MutabilityCategory::from_mutbl(m)
}
- }
+ };
+ debug!("MutabilityCategory::{}({:?}, {:?}) => {:?}",
+ "from_pointer_kind", base_mutbl, ptr, ret);
+ ret
}
fn from_local(tcx: &ty::ctxt, id: ast::NodeId) -> MutabilityCategory {
- match tcx.map.get(id) {
+ let ret = match tcx.map.get(id) {
ast_map::NodeLocal(p) | ast_map::NodeArg(p) => match p.node {
ast::PatIdent(bind_mode, _, _) => {
if bind_mode == ast::BindByValue(ast::MutMutable) {
_ => tcx.sess.span_bug(p.span, "expected identifier pattern")
},
_ => tcx.sess.span_bug(tcx.map.span(id), "expected identifier pattern")
- }
+ };
+ debug!("MutabilityCategory::{}(tcx, id={:?}) => {:?}",
+ "from_local", id, ret);
+ ret
}
pub fn inherit(&self) -> MutabilityCategory {
- match *self {
+ let ret = match *self {
McImmutable => McImmutable,
McDeclared => McInherited,
McInherited => McInherited,
- }
+ };
+ debug!("{:?}.inherit() => {:?}", self, ret);
+ ret
}
pub fn is_mutable(&self) -> bool {
- match *self {
+ let ret = match *self {
McImmutable => false,
McInherited => true,
McDeclared => true,
- }
+ };
+ debug!("{:?}.is_mutable() => {:?}", self, ret);
+ ret
}
pub fn is_immutable(&self) -> bool {
- match *self {
+ let ret = match *self {
McImmutable => true,
McDeclared | McInherited => false
- }
+ };
+ debug!("{:?}.is_immutable() => {:?}", self, ret);
+ ret
}
pub fn to_user_str(&self) -> &'static str {
pub fn cat_expr_autoderefd(&self,
expr: &ast::Expr,
- autoderefs: uint)
+ autoderefs: usize)
-> McResult<cmt<'tcx>> {
let mut cmt = try!(self.cat_expr_unadjusted(expr));
debug!("cat_expr_autoderefd: autoderefs={}, cmt={}",
}
};
- Ok(Rc::new(cmt_result))
+ let ret = Rc::new(cmt_result);
+ debug!("cat_upvar ret={}", ret.repr(self.tcx()));
+ Ok(ret)
}
fn env_deref(&self,
McDeclared | McInherited => { }
}
- cmt_ {
+ let ret = cmt_ {
id: id,
span: span,
cat: cat_deref(Rc::new(cmt_result), 0, env_ptr),
mutbl: deref_mutbl,
ty: var_ty,
note: NoteClosureEnv(upvar_id)
- }
+ };
+
+ debug!("env_deref ret {}", ret.repr(self.tcx()));
+
+ ret
}
pub fn cat_rvalue_node(&self,
}
}
};
- self.cat_rvalue(id, span, re, expr_ty)
+ let ret = self.cat_rvalue(id, span, re, expr_ty);
+ debug!("cat_rvalue_node ret {}", ret.repr(self.tcx()));
+ ret
}
pub fn cat_rvalue(&self,
span: Span,
temp_scope: ty::Region,
expr_ty: Ty<'tcx>) -> cmt<'tcx> {
- Rc::new(cmt_ {
+ let ret = Rc::new(cmt_ {
id:cmt_id,
span:span,
cat:cat_rvalue(temp_scope),
mutbl:McDeclared,
ty:expr_ty,
note: NoteNone
- })
+ });
+ debug!("cat_rvalue ret {}", ret.repr(self.tcx()));
+ ret
}
pub fn cat_field<N:ast_node>(&self,
f_name: ast::Name,
f_ty: Ty<'tcx>)
-> cmt<'tcx> {
- Rc::new(cmt_ {
+ let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_interior(base_cmt, InteriorField(NamedField(f_name))),
ty: f_ty,
note: NoteNone
- })
+ });
+ debug!("cat_field ret {}", ret.repr(self.tcx()));
+ ret
}
pub fn cat_tup_field<N:ast_node>(&self,
node: &N,
base_cmt: cmt<'tcx>,
- f_idx: uint,
+ f_idx: usize,
f_ty: Ty<'tcx>)
-> cmt<'tcx> {
- Rc::new(cmt_ {
+ let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_interior(base_cmt, InteriorField(PositionalField(f_idx))),
ty: f_ty,
note: NoteNone
- })
+ });
+ debug!("cat_tup_field ret {}", ret.repr(self.tcx()));
+ ret
}
fn cat_deref<N:ast_node>(&self,
node: &N,
base_cmt: cmt<'tcx>,
- deref_cnt: uint,
+ deref_cnt: usize,
deref_context: DerefKindContext)
-> McResult<cmt<'tcx>> {
let adjustment = match self.typer.adjustments().borrow().get(&node.id()) {
};
let base_cmt_ty = base_cmt.ty;
match ty::deref(base_cmt_ty, true) {
- Some(mt) => self.cat_deref_common(node, base_cmt, deref_cnt,
+ Some(mt) => {
+ let ret = self.cat_deref_common(node, base_cmt, deref_cnt,
mt.ty,
deref_context,
- /* implicit: */ false),
+ /* implicit: */ false);
+ debug!("cat_deref ret {}", ret.repr(self.tcx()));
+ ret
+ }
None => {
debug!("Explicit deref of non-derefable type: {}",
base_cmt_ty.repr(self.tcx()));
fn cat_deref_common<N:ast_node>(&self,
node: &N,
base_cmt: cmt<'tcx>,
- deref_cnt: uint,
+ deref_cnt: usize,
deref_ty: Ty<'tcx>,
deref_context: DerefKindContext,
implicit: bool)
(base_cmt.mutbl.inherit(), cat_interior(base_cmt, interior))
}
};
- Ok(Rc::new(cmt_ {
+ let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
cat: cat,
mutbl: m,
ty: deref_ty,
note: NoteNone
- }))
+ });
+ debug!("cat_deref_common ret {}", ret.repr(self.tcx()));
+ Ok(ret)
}
pub fn cat_index<N:ast_node>(&self,
};
let m = base_cmt.mutbl.inherit();
- return Ok(interior(elt, base_cmt.clone(), base_cmt.ty,
- m, context, element_ty));
+ let ret = interior(elt, base_cmt.clone(), base_cmt.ty,
+ m, context, element_ty);
+ debug!("cat_index ret {}", ret.repr(self.tcx()));
+ return Ok(ret);
fn interior<'tcx, N: ast_node>(elt: &N,
of_cmt: cmt<'tcx>,
context: InteriorOffsetKind)
-> McResult<cmt<'tcx>>
{
- match try!(deref_kind(base_cmt.ty, Some(context))) {
+ let ret = match try!(deref_kind(base_cmt.ty, Some(context))) {
deref_ptr(ptr) => {
// for unique ptrs, we inherit mutability from the
// owning reference.
let m = MutabilityCategory::from_pointer_kind(base_cmt.mutbl, ptr);
// the deref is explicit in the resulting cmt
- Ok(Rc::new(cmt_ {
+ Rc::new(cmt_ {
id:elt.id(),
span:elt.span(),
cat:cat_deref(base_cmt.clone(), 0, ptr),
None => self.tcx().sess.bug("Found non-derefable type")
},
note: NoteNone
- }))
+ })
}
deref_interior(_) => {
- Ok(base_cmt)
+ base_cmt
}
- }
+ };
+ debug!("deref_vec ret {}", ret.repr(self.tcx()));
+ Ok(ret)
}
/// Given a pattern P like: `[_, ..Q, _]`, where `vec_cmt` is the cmt for `P`, `slice_pat` is
interior_ty: Ty<'tcx>,
interior: InteriorKind)
-> cmt<'tcx> {
- Rc::new(cmt_ {
+ let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_interior(base_cmt, interior),
ty: interior_ty,
note: NoteNone
- })
+ });
+ debug!("cat_imm_interior ret={}", ret.repr(self.tcx()));
+ ret
}
pub fn cat_downcast<N:ast_node>(&self,
downcast_ty: Ty<'tcx>,
variant_did: ast::DefId)
-> cmt<'tcx> {
- Rc::new(cmt_ {
+ let ret = Rc::new(cmt_ {
id: node.id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: cat_downcast(base_cmt, variant_did),
ty: downcast_ty,
note: NoteNone
- })
+ });
+ debug!("cat_downcast ret={}", ret.repr(self.tcx()));
+ ret
}
pub fn cat_pattern<F>(&self, cmt: cmt<'tcx>, pat: &ast::Pat, mut op: F) -> McResult<()>
}
}
-#[derive(Copy)]
+#[derive(Copy, Clone, Debug)]
pub enum InteriorSafety {
InteriorUnsafe,
InteriorSafe
}
-#[derive(Copy)]
+#[derive(Clone, Debug)]
+pub enum Aliasability {
+ FreelyAliasable(AliasableReason),
+ NonAliasable,
+ ImmutableUnique(Box<Aliasability>),
+}
+
+#[derive(Copy, Clone, Debug)]
pub enum AliasableReason {
AliasableBorrowed,
AliasableClosure(ast::NodeId), // Aliasable due to capture Fn closure env
AliasableOther,
+ UnaliasableImmutable, // Created as needed upon seeing ImmutableUnique
AliasableStatic(InteriorSafety),
AliasableStaticMut(InteriorSafety),
}
}
}
- /// Returns `Some(_)` if this lvalue represents a freely aliasable pointer type.
+ /// Returns `FreelyAliasable(_)` if this lvalue represents a freely aliasable pointer type.
pub fn freely_aliasable(&self, ctxt: &ty::ctxt<'tcx>)
- -> Option<AliasableReason> {
+ -> Aliasability {
// Maybe non-obvious: copied upvars can only be considered
// non-aliasable in once closures, since any other kind can be
// aliased and eventually recused.
cat_deref(ref b, _, BorrowedPtr(ty::UniqueImmBorrow, _)) |
cat_deref(ref b, _, Implicit(ty::UniqueImmBorrow, _)) |
cat_downcast(ref b, _) |
- cat_deref(ref b, _, Unique) |
cat_interior(ref b, _) => {
// Aliasability depends on base cmt
b.freely_aliasable(ctxt)
}
+ cat_deref(ref b, _, Unique) => {
+ let sub = b.freely_aliasable(ctxt);
+ if b.mutbl.is_mutable() {
+ // Aliasability depends on base cmt alone
+ sub
+ } else {
+ // Do not allow mutation through an immutable box.
+ ImmutableUnique(Box::new(sub))
+ }
+ }
+
cat_rvalue(..) |
cat_local(..) |
cat_upvar(..) |
cat_deref(_, _, UnsafePtr(..)) => { // yes, it's aliasable, but...
- None
+ NonAliasable
}
cat_static_item(..) => {
};
if self.mutbl.is_mutable() {
- Some(AliasableStaticMut(int_safe))
+ FreelyAliasable(AliasableStaticMut(int_safe))
} else {
- Some(AliasableStatic(int_safe))
+ FreelyAliasable(AliasableStatic(int_safe))
}
}
cat_deref(ref base, _, BorrowedPtr(ty::ImmBorrow, _)) |
cat_deref(ref base, _, Implicit(ty::ImmBorrow, _)) => {
match base.cat {
- cat_upvar(Upvar{ id, .. }) => Some(AliasableClosure(id.closure_expr_id)),
- _ => Some(AliasableBorrowed)
+ cat_upvar(Upvar{ id, .. }) =>
+ FreelyAliasable(AliasableClosure(id.closure_expr_id)),
+ _ => FreelyAliasable(AliasableBorrowed)
}
}
}
use util::nodemap::FnvHashMap;
use syntax::ast;
-use syntax::ast_util::{walk_pat};
+use syntax::ast_util::walk_pat;
use syntax::codemap::{Span, DUMMY_SP};
pub type PatIdMap = FnvHashMap<ast::Ident, ast::NodeId>;
use syntax::codemap::{self, Span};
use syntax::{ast, visit};
use syntax::ast::{Block, Item, FnDecl, NodeId, Arm, Pat, Stmt, Expr, Local};
-use syntax::ast_util::{stmt_id};
+use syntax::ast_util::stmt_id;
use syntax::ast_map;
use syntax::ptr::P;
use syntax::visit::{Visitor, FnKind};
RustcDecodable, Debug, Copy)]
pub struct BlockRemainder {
pub block: ast::NodeId,
- pub first_statement_index: uint,
+ pub first_statement_index: usize,
}
impl CodeExtent {
struct DeclaringStatementContext {
stmt_id: ast::NodeId,
block_id: ast::NodeId,
- stmt_index: uint,
+ stmt_index: usize,
}
impl DeclaringStatementContext {
use syntax::codemap::Span;
use syntax::parse::token::special_idents;
use syntax::parse::token;
-use syntax::print::pprust::{lifetime_to_string};
+use syntax::print::pprust::lifetime_to_string;
use syntax::visit;
use syntax::visit::Visitor;
use util::nodemap::NodeMap;
}
pub fn type_for_def(&self, ty_param_def: &ty::TypeParameterDef) -> Ty<'tcx> {
- *self.types.get(ty_param_def.space, ty_param_def.index as uint)
+ *self.types.get(ty_param_def.space, ty_param_def.index as usize)
}
pub fn has_regions_escaping_depth(&self, depth: u32) -> bool {
[TypeSpace, SelfSpace, FnSpace]
}
- pub fn to_uint(self) -> uint {
+ pub fn to_uint(self) -> usize {
match self {
TypeSpace => 0,
SelfSpace => 1,
}
}
- pub fn from_uint(u: uint) -> ParamSpace {
+ pub fn from_uint(u: usize) -> ParamSpace {
match u {
0 => TypeSpace,
1 => SelfSpace,
// AF(self) = (self.content[..self.type_limit],
// self.content[self.type_limit..self.self_limit],
// self.content[self.self_limit..])
- type_limit: uint,
- self_limit: uint,
+ type_limit: usize,
+ self_limit: usize,
content: Vec<T>,
}
}
impl<T> VecPerParamSpace<T> {
- fn limits(&self, space: ParamSpace) -> (uint, uint) {
+ fn limits(&self, space: ParamSpace) -> (usize, usize) {
match space {
TypeSpace => (0, self.type_limit),
SelfSpace => (self.type_limit, self.self_limit),
}
}
- fn new_internal(content: Vec<T>, type_limit: uint, self_limit: uint)
+ fn new_internal(content: Vec<T>, type_limit: usize, self_limit: usize)
-> VecPerParamSpace<T>
{
VecPerParamSpace {
}
}
- pub fn truncate(&mut self, space: ParamSpace, len: uint) {
+ pub fn truncate(&mut self, space: ParamSpace, len: usize) {
// FIXME (#15435): slow; O(n^2); could enhance vec to make it O(n).
while self.len(space) > len {
self.pop(space);
if v.len() == 0 { None } else { Some(&v[0]) }
}
- pub fn len(&self, space: ParamSpace) -> uint {
+ pub fn len(&self, space: ParamSpace) -> usize {
self.get_slice(space).len()
}
pub fn opt_get<'a>(&'a self,
space: ParamSpace,
- index: uint)
+ index: usize)
-> Option<&'a T> {
let v = self.get_slice(space);
if index < v.len() { Some(&v[index]) } else { None }
}
- pub fn get<'a>(&'a self, space: ParamSpace, index: uint) -> &'a T {
+ pub fn get<'a>(&'a self, space: ParamSpace, index: usize) -> &'a T {
&self.get_slice(space)[index]
}
}
pub fn map_enumerated<U, P>(&self, pred: P) -> VecPerParamSpace<U> where
- P: FnMut((ParamSpace, uint, &T)) -> U,
+ P: FnMut((ParamSpace, usize, &T)) -> U,
{
let result = self.iter_enumerated().map(pred).collect();
VecPerParamSpace::new_internal(result,
#[derive(Clone)]
pub struct EnumeratedItems<'a,T:'a> {
vec: &'a VecPerParamSpace<T>,
- space_index: uint,
- elem_index: uint
+ space_index: usize,
+ elem_index: usize
}
impl<'a,T> EnumeratedItems<'a,T> {
}
impl<'a,T> Iterator for EnumeratedItems<'a,T> {
- type Item = (ParamSpace, uint, &'a T);
+ type Item = (ParamSpace, usize, &'a T);
- fn next(&mut self) -> Option<(ParamSpace, uint, &'a T)> {
+ fn next(&mut self) -> Option<(ParamSpace, usize, &'a T)> {
let spaces = ParamSpace::all();
if self.space_index < spaces.len() {
let space = spaces[self.space_index];
root_ty: Option<Ty<'tcx>>,
// Depth of type stack
- ty_stack_depth: uint,
+ ty_stack_depth: usize,
// Number of region binders we have passed through while doing the substitution
region_binders_passed: u32,
match self.substs.regions {
ErasedRegions => ty::ReStatic,
NonerasedRegions(ref regions) =>
- match regions.opt_get(space, i as uint) {
+ match regions.opt_get(space, i as usize) {
Some(&r) => {
self.shift_region_through_binders(r)
}
impl<'a,'tcx> SubstFolder<'a,'tcx> {
fn ty_for_param(&self, p: ty::ParamTy, source_ty: Ty<'tcx>) -> Ty<'tcx> {
// Look up the type in the substitutions. It really should be in there.
- let opt_ty = self.substs.types.opt_get(p.space, p.idx as uint);
+ let opt_ty = self.substs.types.opt_get(p.space, p.idx as usize);
let ty = match opt_ty {
Some(t) => *t,
None => {
use super::Normalized;
use super::SelectionContext;
-use super::{ObligationCause};
+use super::ObligationCause;
use super::PredicateObligation;
use super::project;
use super::util;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use middle::infer::{InferCtxt};
+use middle::infer::InferCtxt;
use middle::ty::{self, RegionEscape, Ty};
use std::collections::HashSet;
use std::default::Default;
// Remembers the count of trait obligations that we have already
// attempted to select. This is used to avoid repeating work
// when `select_new_obligations` is called.
- attempted_mark: uint,
+ attempted_mark: usize,
// A set of constraints that regionck must validate. Each
// constraint has the form `T:'a`, meaning "some type `T` must
// debug output much nicer to read and so on.
let obligation = infcx.resolve_type_vars_if_possible(&obligation);
+ assert!(!obligation.has_escaping_regions());
+
if !self.duplicate_set.insert(obligation.predicate.clone()) {
debug!("register_predicate({}) -- already seen, skip", obligation.repr(infcx.tcx));
return;
pub use self::object_safety::object_safety_violations;
pub use self::object_safety::ObjectSafetyViolation;
pub use self::object_safety::MethodViolationCode;
+pub use self::object_safety::is_vtable_safe_method;
pub use self::select::SelectionContext;
pub use self::select::SelectionCache;
pub use self::select::{MethodMatchResult, MethodMatched, MethodAmbiguous, MethodDidNotMatch};
pub use self::util::trait_ref_for_builtin_bound;
pub use self::util::supertraits;
pub use self::util::Supertraits;
+pub use self::util::supertrait_def_ids;
+pub use self::util::SupertraitDefIds;
pub use self::util::transitive_bounds;
pub use self::util::upcast;
#[derive(Clone, PartialEq, Eq)]
pub struct Obligation<'tcx, T> {
pub cause: ObligationCause<'tcx>,
- pub recursion_depth: uint,
+ pub recursion_depth: usize,
pub predicate: T,
}
}
fn with_depth(cause: ObligationCause<'tcx>,
- recursion_depth: uint,
+ recursion_depth: usize,
trait_ref: O)
-> Obligation<'tcx, O>
{
}
impl<'tcx> TraitObligation<'tcx> {
- fn self_ty(&self) -> Ty<'tcx> {
- self.predicate.0.self_ty()
+ fn self_ty(&self) -> ty::Binder<Ty<'tcx>> {
+ ty::Binder(self.predicate.skip_binder().self_ty())
}
}
}
pub fn is_object_safe<'tcx>(tcx: &ty::ctxt<'tcx>,
- trait_ref: ty::PolyTraitRef<'tcx>)
+ trait_def_id: ast::DefId)
-> bool
{
// Because we query yes/no results frequently, we keep a cache:
let cached_result =
- tcx.object_safety_cache.borrow().get(&trait_ref.def_id()).cloned();
+ tcx.object_safety_cache.borrow().get(&trait_def_id).cloned();
let result =
cached_result.unwrap_or_else(|| {
- let result = object_safety_violations(tcx, trait_ref.clone()).is_empty();
+ let result = object_safety_violations(tcx, trait_def_id).is_empty();
// Record just a yes/no result in the cache; this is what is
// queried most frequently. Note that this may overwrite a
// previous result, but always with the same thing.
- tcx.object_safety_cache.borrow_mut().insert(trait_ref.def_id(), result);
+ tcx.object_safety_cache.borrow_mut().insert(trait_def_id, result);
result
});
- debug!("is_object_safe({}) = {}", trait_ref.repr(tcx), result);
+ debug!("is_object_safe({}) = {}", trait_def_id.repr(tcx), result);
result
}
pub fn object_safety_violations<'tcx>(tcx: &ty::ctxt<'tcx>,
- sub_trait_ref: ty::PolyTraitRef<'tcx>)
+ trait_def_id: ast::DefId)
-> Vec<ObjectSafetyViolation<'tcx>>
{
- supertraits(tcx, sub_trait_ref)
- .flat_map(|tr| object_safety_violations_for_trait(tcx, tr.def_id()).into_iter())
+ traits::supertrait_def_ids(tcx, trait_def_id)
+ .flat_map(|def_id| object_safety_violations_for_trait(tcx, def_id).into_iter())
.collect()
}
.flat_map(|item| {
match *item {
ty::MethodTraitItem(ref m) => {
- object_safety_violations_for_method(tcx, trait_def_id, &**m)
+ object_safety_violation_for_method(tcx, trait_def_id, &**m)
.map(|code| ObjectSafetyViolation::Method(m.clone(), code))
.into_iter()
}
})
}
-fn object_safety_violations_for_method<'tcx>(tcx: &ty::ctxt<'tcx>,
- trait_def_id: ast::DefId,
- method: &ty::Method<'tcx>)
- -> Option<MethodViolationCode>
+/// Returns `Some(_)` if this method makes the containing trait not object safe.
+fn object_safety_violation_for_method<'tcx>(tcx: &ty::ctxt<'tcx>,
+ trait_def_id: ast::DefId,
+ method: &ty::Method<'tcx>)
+ -> Option<MethodViolationCode>
{
// Any method that has a `Self : Sized` requisite is otherwise
// exempt from the regulations.
return None;
}
+ virtual_call_violation_for_method(tcx, trait_def_id, method)
+}
+
+/// We say a method is *vtable safe* if it can be invoked on a trait
+/// object. Note that object-safe traits can have some
+/// non-vtable-safe methods, so long as they require `Self:Sized` or
+/// otherwise ensure that they cannot be used when `Self=Trait`.
+pub fn is_vtable_safe_method<'tcx>(tcx: &ty::ctxt<'tcx>,
+ trait_def_id: ast::DefId,
+ method: &ty::Method<'tcx>)
+ -> bool
+{
+ virtual_call_violation_for_method(tcx, trait_def_id, method).is_none()
+}
+
+/// Returns `Some(_)` if this method cannot be called on a trait
+/// object; this does not necessarily imply that the enclosing trait
+/// is not object safe, because the method might have a where clause
+/// `Self:Sized`.
+fn virtual_call_violation_for_method<'tcx>(tcx: &ty::ctxt<'tcx>,
+ trait_def_id: ast::DefId,
+ method: &ty::Method<'tcx>)
+ -> Option<MethodViolationCode>
+{
// The method's first parameter must be something that derefs (or
// autorefs) to `&self`. For now, we only accept `self`, `&self`
// and `Box<Self>`.
/// As `normalize`, but with a custom depth.
pub fn normalize_with_depth<'a,'b,'tcx,T>(selcx: &'a mut SelectionContext<'b,'tcx>,
cause: ObligationCause<'tcx>,
- depth: uint,
+ depth: usize,
value: &T)
-> Normalized<'tcx, T>
where T : TypeFoldable<'tcx> + HasProjectionTypes + Clone + Repr<'tcx>
selcx: &'a mut SelectionContext<'b,'tcx>,
cause: ObligationCause<'tcx>,
obligations: Vec<PredicateObligation<'tcx>>,
- depth: uint,
+ depth: usize,
}
impl<'a,'b,'tcx> AssociatedTypeNormalizer<'a,'b,'tcx> {
fn new(selcx: &'a mut SelectionContext<'b,'tcx>,
cause: ObligationCause<'tcx>,
- depth: uint)
+ depth: usize)
-> AssociatedTypeNormalizer<'a,'b,'tcx>
{
AssociatedTypeNormalizer {
selcx: &'a mut SelectionContext<'b,'tcx>,
projection_ty: ty::ProjectionTy<'tcx>,
cause: ObligationCause<'tcx>,
- depth: uint)
+ depth: usize)
-> NormalizedTy<'tcx>
{
opt_normalize_projection_type(selcx, projection_ty.clone(), cause.clone(), depth)
selcx: &'a mut SelectionContext<'b,'tcx>,
projection_ty: ty::ProjectionTy<'tcx>,
cause: ObligationCause<'tcx>,
- depth: uint)
+ depth: usize)
-> Option<NormalizedTy<'tcx>>
{
debug!("normalize_projection_type(\
fn normalize_to_error<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
projection_ty: ty::ProjectionTy<'tcx>,
cause: ObligationCause<'tcx>,
- depth: uint)
+ depth: usize)
-> NormalizedTy<'tcx>
{
let trait_ref = projection_ty.trait_ref.to_poly_trait_ref();
// But wait, you say! What about an example like this:
//
// ```
- // fn bar<T:SomeTrait<Foo=uint>>(...) { ... }
+ // fn bar<T:SomeTrait<Foo=usize>>(...) { ... }
// ```
//
- // Doesn't the `T : Sometrait<Foo=uint>` predicate help
+ // Doesn't the `T : Sometrait<Foo=usize>` predicate help
// resolve `T::Foo`? And of course it does, but in fact
// that single predicate is desugared into two predicates
// in the compiler: a trait predicate (`T : SomeTrait`) and a
use super::project;
use super::project::{normalize_with_depth, Normalized};
use super::{PredicateObligation, TraitObligation, ObligationCause};
-use super::{report_overflow_error};
+use super::report_overflow_error;
use super::{ObligationCauseCode, BuiltinDerivedObligation, ImplDerivedObligation};
use super::{SelectionError, Unimplemented, OutputTypeParameterMismatch};
-use super::{Selection};
-use super::{SelectionResult};
+use super::Selection;
+use super::SelectionResult;
use super::{VtableBuiltin, VtableImpl, VtableParam, VtableClosure,
VtableFnPointer, VtableObject, VtableDefaultImpl};
use super::{VtableImplData, VtableObjectData, VtableBuiltinData, VtableDefaultImplData};
use super::object_safety;
-use super::{util};
+use super::util;
use middle::fast_reject;
use middle::subst::{Subst, Substs, TypeSpace, VecPerParamSpace};
/// The selection process begins by considering all impls, where
/// clauses, and so forth that might resolve an obligation. Sometimes
/// we'll be able to say definitively that (e.g.) an impl does not
-/// apply to the obligation: perhaps it is defined for `uint` but the
+/// apply to the obligation: perhaps it is defined for `usize` but the
/// obligation is for `int`. In that case, we drop the impl out of the
/// list. But the other cases are considered *candidates*.
///
ParamCandidate(ty::PolyTraitRef<'tcx>),
ImplCandidate(ast::DefId),
DefaultImplCandidate(ast::DefId),
+ DefaultImplObjectCandidate(ast::DefId),
/// This is a trait matching with a projected type as `Self`, and
/// we found an applicable bound in the trait definition.
}
enum BuiltinBoundConditions<'tcx> {
- If(Vec<Ty<'tcx>>),
+ If(ty::Binder<Vec<Ty<'tcx>>>),
ParameterBuiltin,
AmbiguousBuiltin
}
// because if it is a closure type, it must be a closure type from
// within this current fn, and hence none of the higher-ranked
// lifetimes can appear inside the self-type.
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
+ let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
let (closure_def_id, substs) = match self_ty.sty {
ty::ty_closure(id, ref substs) => (id, substs.clone()),
_ => { return; }
// for example, we are looking for $0:Eq where $0 is some
// unconstrained type variable. In that case, we'll get a
// candidate which assumes $0 == int, one that assumes $0 ==
- // uint, etc. This spells an ambiguity.
+ // usize, etc. This spells an ambiguity.
// If there is more than one candidate, first winnow them down
// by considering extra conditions (nested obligations and so
None => { return Ok(()); }
};
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
+ // ok to skip binder because the substs on closure types never
+ // touch bound regions, they just capture the in-scope
+ // type/region parameters
+ let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
let (closure_def_id, substs) = match self_ty.sty {
ty::ty_closure(id, ref substs) => (id, substs.clone()),
ty::ty_infer(ty::TyVar(_)) => {
return Ok(());
}
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
+ // ok to skip binder because what we are inspecting doesn't involve bound regions
+ let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
match self_ty.sty {
ty::ty_infer(ty::TyVar(_)) => {
debug!("assemble_fn_pointer_candidates: ambiguous self-type");
candidates: &mut SelectionCandidateSet<'tcx>)
-> Result<(), SelectionError<'tcx>>
{
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
- debug!("assemble_candidates_from_impls(self_ty={})", self_ty.repr(self.tcx()));
+ debug!("assemble_candidates_from_impls(obligation={})", obligation.repr(self.tcx()));
let def_id = obligation.predicate.def_id();
let all_impls = self.all_impls(def_id);
candidates: &mut SelectionCandidateSet<'tcx>)
-> Result<(), SelectionError<'tcx>>
{
-
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
+ // OK to skip binder here because the tests we do below do not involve bound regions
+ let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
debug!("assemble_candidates_from_default_impls(self_ty={})", self_ty.repr(self.tcx()));
let def_id = obligation.predicate.def_id();
if ty::trait_has_default_impl(self.tcx(), def_id) {
match self_ty.sty {
- ty::ty_trait(..) |
+ ty::ty_trait(..) => {
+ // For object types, we don't know what the closed
+ // over types are. For most traits, this means we
+ // conservatively say nothing; a candidate may be
+ // added by `assemble_candidates_from_object_ty`.
+ // However, for the kind of magic reflect trait,
+ // we consider it to be implemented even for
+ // object types, because it just lets you reflect
+ // onto the object type, not into the object's
+ // interior.
+ if ty::has_attr(self.tcx(), def_id, "rustc_reflect_like") {
+ candidates.vec.push(DefaultImplObjectCandidate(def_id));
+ }
+ }
ty::ty_param(..) |
ty::ty_projection(..) => {
// In these cases, we don't know what the actual
obligation: &TraitObligation<'tcx>,
candidates: &mut SelectionCandidateSet<'tcx>)
{
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
-
debug!("assemble_candidates_from_object_ty(self_ty={})",
- self_ty.repr(self.tcx()));
+ self.infcx.shallow_resolve(*obligation.self_ty().skip_binder()).repr(self.tcx()));
// Object-safety candidates are only applicable to object-safe
// traits. Including this check is useful because it helps
// self-type from one of the other inputs. Without this check,
// these cases wind up being considered ambiguous due to a
// (spurious) ambiguity introduced here.
- if !object_safety::is_object_safe(self.tcx(), obligation.predicate.to_poly_trait_ref()) {
+ let predicate_trait_ref = obligation.predicate.to_poly_trait_ref();
+ if !object_safety::is_object_safe(self.tcx(), predicate_trait_ref.def_id()) {
return;
}
- let poly_trait_ref = match self_ty.sty {
- ty::ty_trait(ref data) => {
- match self.tcx().lang_items.to_builtin_kind(obligation.predicate.def_id()) {
- Some(bound @ ty::BoundSend) | Some(bound @ ty::BoundSync) => {
- if data.bounds.builtin_bounds.contains(&bound) {
- debug!("assemble_candidates_from_object_ty: matched builtin bound, \
- pushing candidate");
- candidates.vec.push(BuiltinObjectCandidate);
- return;
+ self.infcx.try(|snapshot| {
+ let bound_self_ty =
+ self.infcx.resolve_type_vars_if_possible(&obligation.self_ty());
+ let (self_ty, _) =
+ self.infcx().skolemize_late_bound_regions(&bound_self_ty, snapshot);
+ let poly_trait_ref = match self_ty.sty {
+ ty::ty_trait(ref data) => {
+ match self.tcx().lang_items.to_builtin_kind(obligation.predicate.def_id()) {
+ Some(bound @ ty::BoundSend) | Some(bound @ ty::BoundSync) => {
+ if data.bounds.builtin_bounds.contains(&bound) {
+ debug!("assemble_candidates_from_object_ty: matched builtin bound, \
+ pushing candidate");
+ candidates.vec.push(BuiltinObjectCandidate);
+ return Ok(());
+ }
}
+ _ => {}
}
- _ => {}
+
+ data.principal_trait_ref_with_self_ty(self.tcx(), self_ty)
+ }
+ ty::ty_infer(ty::TyVar(_)) => {
+ debug!("assemble_candidates_from_object_ty: ambiguous");
+ candidates.ambiguous = true; // could wind up being an object type
+ return Ok(());
+ }
+ _ => {
+ return Ok(());
}
+ };
- data.principal_trait_ref_with_self_ty(self.tcx(), self_ty)
- }
- ty::ty_infer(ty::TyVar(_)) => {
- debug!("assemble_candidates_from_object_ty: ambiguous");
- candidates.ambiguous = true; // could wind up being an object type
- return;
- }
- _ => {
- return;
- }
- };
+ debug!("assemble_candidates_from_object_ty: poly_trait_ref={}",
+ poly_trait_ref.repr(self.tcx()));
- debug!("assemble_candidates_from_object_ty: poly_trait_ref={}",
- poly_trait_ref.repr(self.tcx()));
+ // see whether the object trait can be upcast to the trait we are looking for
+ let upcast_trait_refs = self.upcast(poly_trait_ref, obligation);
+ if upcast_trait_refs.len() > 1 {
+ // can be upcast in many ways; need more type information
+ candidates.ambiguous = true;
+ } else if upcast_trait_refs.len() == 1 {
+ candidates.vec.push(ObjectCandidate);
+ }
- // see whether the object trait can be upcast to the trait we are looking for
- let upcast_trait_refs = self.upcast(poly_trait_ref, obligation);
- if upcast_trait_refs.len() > 1 {
- // can be upcast in many ways; need more type information
- candidates.ambiguous = true;
- } else if upcast_trait_refs.len() == 1 {
- candidates.vec.push(ObjectCandidate);
- }
+ Ok::<(),()>(())
+ }).unwrap();
}
///////////////////////////////////////////////////////////////////////////
let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty());
return match self_ty.sty {
- ty::ty_infer(ty::IntVar(_))
- | ty::ty_infer(ty::FloatVar(_))
- | ty::ty_uint(_)
- | ty::ty_int(_)
- | ty::ty_bool
- | ty::ty_float(_)
- | ty::ty_bare_fn(..)
- | ty::ty_char => {
+ ty::ty_infer(ty::IntVar(_)) |
+ ty::ty_infer(ty::FloatVar(_)) |
+ ty::ty_uint(_) |
+ ty::ty_int(_) |
+ ty::ty_bool |
+ ty::ty_float(_) |
+ ty::ty_bare_fn(..) |
+ ty::ty_char => {
// safe for everything
- Ok(If(Vec::new()))
+ ok_if(Vec::new())
}
ty::ty_uniq(_) => { // Box<T>
match bound {
ty::BoundCopy => Err(Unimplemented),
- ty::BoundSized => Ok(If(Vec::new())),
+ ty::BoundSized => ok_if(Vec::new()),
ty::BoundSync | ty::BoundSend => {
self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()");
ty::ty_ptr(..) => { // *const T, *mut T
match bound {
- ty::BoundCopy | ty::BoundSized => Ok(If(Vec::new())),
+ ty::BoundCopy | ty::BoundSized => ok_if(Vec::new()),
ty::BoundSync | ty::BoundSend => {
self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()");
ty::BoundSized => Err(Unimplemented),
ty::BoundCopy => {
if data.bounds.builtin_bounds.contains(&bound) {
- Ok(If(Vec::new()))
+ ok_if(Vec::new())
} else {
// Recursively check all supertraits to find out if any further
// bounds are required and thus we must fulfill.
let desired_def_id = obligation.predicate.def_id();
for tr in util::supertraits(self.tcx(), principal) {
if tr.def_id() == desired_def_id {
- return Ok(If(Vec::new()))
+ return ok_if(Vec::new())
}
}
ast::MutMutable => Err(Unimplemented),
// &T is always copyable
- ast::MutImmutable => Ok(If(Vec::new())),
+ ast::MutImmutable => ok_if(Vec::new()),
}
}
- ty::BoundSized => Ok(If(Vec::new())),
+ ty::BoundSized => ok_if(Vec::new()),
ty::BoundSync | ty::BoundSend => {
self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()");
ty::BoundCopy => {
match *len {
// [T, ..n] is copy iff T is copy
- Some(_) => Ok(If(vec![element_ty])),
+ Some(_) => ok_if(vec![element_ty]),
// [T] is unsized and hence affine
None => Err(Unimplemented),
ty::BoundSized => {
if len.is_some() {
- Ok(If(Vec::new()))
+ ok_if(Vec::new())
} else {
Err(Unimplemented)
}
}
// (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
- ty::ty_tup(ref tys) => Ok(If(tys.clone())),
+ ty::ty_tup(ref tys) => ok_if(tys.clone()),
ty::ty_closure(def_id, substs) => {
// FIXME -- This case is tricky. In the case of by-ref
// unsized, so the closure struct as a whole must be
// Sized.
if bound == ty::BoundSized {
- return Ok(If(Vec::new()));
+ return ok_if(Vec::new());
}
match self.closure_typer.closure_upvars(def_id, substs) {
- Some(upvars) => Ok(If(upvars.iter().map(|c| c.ty).collect())),
+ Some(upvars) => ok_if(upvars.iter().map(|c| c.ty).collect()),
None => {
debug!("assemble_builtin_bound_candidates: no upvar types available yet");
Ok(AmbiguousBuiltin)
Ok(AmbiguousBuiltin)
}
- ty::ty_err => Ok(If(Vec::new())),
+ ty::ty_err => ok_if(Vec::new()),
ty::ty_infer(ty::FreshTy(_))
| ty::ty_infer(ty::FreshIntTy(_)) => {
}
};
+ fn ok_if<'tcx>(v: Vec<Ty<'tcx>>)
+ -> Result<BuiltinBoundConditions<'tcx>, SelectionError<'tcx>> {
+ Ok(If(ty::Binder(v)))
+ }
+
fn nominal<'cx, 'tcx>(bound: ty::BuiltinBound,
types: Vec<Ty<'tcx>>)
-> Result<BuiltinBoundConditions<'tcx>, SelectionError<'tcx>>
ty::BoundCopy => Ok(ParameterBuiltin),
// Sized if all the component types are sized.
- ty::BoundSized => Ok(If(types)),
+ ty::BoundSized => ok_if(types),
// Shouldn't be coming through here.
ty::BoundSend | ty::BoundSync => unreachable!(),
fn collect_predicates_for_types(&mut self,
obligation: &TraitObligation<'tcx>,
trait_def_id: ast::DefId,
- types: Vec<Ty<'tcx>>) -> Vec<PredicateObligation<'tcx>> {
-
+ types: ty::Binder<Vec<Ty<'tcx>>>)
+ -> Vec<PredicateObligation<'tcx>>
+ {
let derived_cause = match self.tcx().lang_items.to_builtin_kind(trait_def_id) {
Some(_) => {
self.derived_cause(obligation, BuiltinDerivedObligation)
}
};
- let normalized = project::normalize_with_depth(self, obligation.cause.clone(),
- obligation.recursion_depth + 1,
- &types);
-
- let obligations = normalized.value.iter().map(|&nested_ty| {
- // the obligation might be higher-ranked, e.g. for<'a> &'a
- // int : Copy. In that case, we will wind up with
- // late-bound regions in the `nested` vector. So for each
- // one we instantiate to a skolemized region, do our work
- // to produce something like `&'0 int : Copy`, and then
- // re-bind it. This is a bit of busy-work but preserves
- // the invariant that we only manipulate free regions, not
- // bound ones.
+ // Because the types were potentially derived from
+ // higher-ranked obligations they may reference late-bound
+ // regions. For example, `for<'a> Foo<&'a int> : Copy` would
+ // yield a type like `for<'a> &'a int`. In general, we
+ // maintain the invariant that we never manipulate bound
+ // regions, so we have to process these bound regions somehow.
+ //
+ // The strategy is to:
+ //
+ // 1. Instantiate those regions to skolemized regions (e.g.,
+ // `for<'a> &'a int` becomes `&0 int`.
+ // 2. Produce something like `&'0 int : Copy`
+ // 3. Re-bind the regions back to `for<'a> &'a int : Copy`
+
+ // Move the binder into the individual types
+ let bound_types: Vec<ty::Binder<Ty<'tcx>>> =
+ types.skip_binder()
+ .iter()
+ .map(|&nested_ty| ty::Binder(nested_ty))
+ .collect();
+
+ // For each type, produce a vector of resulting obligations
+ let obligations: Result<Vec<Vec<_>>, _> = bound_types.iter().map(|nested_ty| {
self.infcx.try(|snapshot| {
let (skol_ty, skol_map) =
- self.infcx().skolemize_late_bound_regions(&ty::Binder(nested_ty), snapshot);
- let skol_predicate =
- util::predicate_for_trait_def(
- self.tcx(),
- derived_cause.clone(),
- trait_def_id,
- obligation.recursion_depth + 1,
- skol_ty);
- match skol_predicate {
- Ok(skol_predicate) => Ok(self.infcx().plug_leaks(skol_map, snapshot,
- &skol_predicate)),
- Err(ErrorReported) => Err(ErrorReported)
- }
+ self.infcx().skolemize_late_bound_regions(nested_ty, snapshot);
+ let Normalized { value: normalized_ty, mut obligations } =
+ project::normalize_with_depth(self,
+ obligation.cause.clone(),
+ obligation.recursion_depth + 1,
+ &skol_ty);
+ let skol_obligation =
+ try!(util::predicate_for_trait_def(self.tcx(),
+ derived_cause.clone(),
+ trait_def_id,
+ obligation.recursion_depth + 1,
+ normalized_ty));
+ obligations.push(skol_obligation);
+ Ok(self.infcx().plug_leaks(skol_map, snapshot, &obligations))
})
- }).collect::<Result<Vec<PredicateObligation<'tcx>>, _>>();
+ }).collect();
+ // Flatten those vectors (couldn't do it above due `collect`)
match obligations {
- Ok(mut obls) => {
- obls.push_all(&normalized.obligations);
- obls
- },
- Err(ErrorReported) => Vec::new()
+ Ok(obligations) => obligations.into_iter().flat_map(|o| o.into_iter()).collect(),
+ Err(ErrorReported) => Vec::new(),
}
}
}
DefaultImplCandidate(trait_def_id) => {
- let data = try!(self.confirm_default_impl_candidate(obligation, trait_def_id));
+ let data = self.confirm_default_impl_candidate(obligation, trait_def_id);
+ Ok(VtableDefaultImpl(data))
+ }
+
+ DefaultImplObjectCandidate(trait_def_id) => {
+ let data = self.confirm_default_impl_object_candidate(obligation, trait_def_id);
Ok(VtableDefaultImpl(data))
}
fn vtable_builtin_data(&mut self,
obligation: &TraitObligation<'tcx>,
bound: ty::BuiltinBound,
- nested: Vec<Ty<'tcx>>)
+ nested: ty::Binder<Vec<Ty<'tcx>>>)
-> VtableBuiltinData<PredicateObligation<'tcx>>
{
let trait_def = match self.tcx().lang_items.from_builtin_kind(bound) {
/// 2. For each where-clause `C` declared on `Foo`, `[Self => X] C` holds.
fn confirm_default_impl_candidate(&mut self,
obligation: &TraitObligation<'tcx>,
- impl_def_id: ast::DefId)
- -> Result<VtableDefaultImplData<PredicateObligation<'tcx>>,
- SelectionError<'tcx>>
+ trait_def_id: ast::DefId)
+ -> VtableDefaultImplData<PredicateObligation<'tcx>>
{
debug!("confirm_default_impl_candidate({}, {})",
obligation.repr(self.tcx()),
- impl_def_id.repr(self.tcx()));
+ trait_def_id.repr(self.tcx()));
- let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty());
+ // binder is moved below
+ let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
match self.constituent_types_for_ty(self_ty) {
- Some(types) => Ok(self.vtable_default_impl(obligation, impl_def_id, types)),
+ Some(types) => self.vtable_default_impl(obligation, trait_def_id, ty::Binder(types)),
None => {
self.tcx().sess.bug(
&format!(
}
}
+ fn confirm_default_impl_object_candidate(&mut self,
+ obligation: &TraitObligation<'tcx>,
+ trait_def_id: ast::DefId)
+ -> VtableDefaultImplData<PredicateObligation<'tcx>>
+ {
+ debug!("confirm_default_impl_object_candidate({}, {})",
+ obligation.repr(self.tcx()),
+ trait_def_id.repr(self.tcx()));
+
+ assert!(ty::has_attr(self.tcx(), trait_def_id, "rustc_reflect_like"));
+
+ // OK to skip binder, it is reintroduced below
+ let self_ty = self.infcx.shallow_resolve(obligation.predicate.skip_binder().self_ty());
+ match self_ty.sty {
+ ty::ty_trait(ref data) => {
+ // OK to skip the binder, it is reintroduced below
+ let input_types = data.principal.skip_binder().substs.types.get_slice(TypeSpace);
+ let assoc_types = data.bounds.projection_bounds
+ .iter()
+ .map(|pb| pb.skip_binder().ty);
+ let all_types: Vec<_> = input_types.iter().cloned()
+ .chain(assoc_types)
+ .collect();
+
+ // reintroduce the two binding levels we skipped, then flatten into one
+ let all_types = ty::Binder(ty::Binder(all_types));
+ let all_types = ty::flatten_late_bound_regions(self.tcx(), &all_types);
+
+ self.vtable_default_impl(obligation, trait_def_id, all_types)
+ }
+ _ => {
+ self.tcx().sess.bug(
+ &format!(
+ "asked to confirm default object implementation for non-object type: {}",
+ self_ty.repr(self.tcx())));
+ }
+ }
+ }
+
/// See `confirm_default_impl_candidate`
fn vtable_default_impl(&mut self,
obligation: &TraitObligation<'tcx>,
trait_def_id: ast::DefId,
- nested: Vec<Ty<'tcx>>)
+ nested: ty::Binder<Vec<Ty<'tcx>>>)
-> VtableDefaultImplData<PredicateObligation<'tcx>>
{
+ debug!("vtable_default_impl_data: nested={}", nested.repr(self.tcx()));
let mut obligations = self.collect_predicates_for_types(obligation,
trait_def_id,
nested);
- let _: Result<(),()> = self.infcx.try(|snapshot| {
- let (_, skol_map) =
- self.infcx().skolemize_late_bound_regions(&obligation.predicate, snapshot);
-
- let substs = obligation.predicate.to_poly_trait_ref().substs();
- let trait_obligations = self.impl_or_trait_obligations(obligation.cause.clone(),
- obligation.recursion_depth + 1,
- trait_def_id,
- substs,
- skol_map,
- snapshot);
- obligations.push_all(trait_obligations.as_slice());
- Ok(())
+ let trait_obligations: Result<VecPerParamSpace<_>,()> = self.infcx.try(|snapshot| {
+ let poly_trait_ref = obligation.predicate.to_poly_trait_ref();
+ let (trait_ref, skol_map) =
+ self.infcx().skolemize_late_bound_regions(&poly_trait_ref, snapshot);
+ Ok(self.impl_or_trait_obligations(obligation.cause.clone(),
+ obligation.recursion_depth + 1,
+ trait_def_id,
+ &trait_ref.substs,
+ skol_map,
+ snapshot))
});
+ obligations.extend(trait_obligations.unwrap().into_iter()); // no Errors in that code above
+
debug!("vtable_default_impl_data: obligations={}", obligations.repr(self.tcx()));
VtableDefaultImplData {
impl_def_id: ast::DefId,
substs: Normalized<'tcx, Substs<'tcx>>,
cause: ObligationCause<'tcx>,
- recursion_depth: uint,
+ recursion_depth: usize,
skol_map: infer::SkolemizationMap,
snapshot: &infer::CombinedSnapshot)
-> VtableImplData<'tcx, PredicateObligation<'tcx>>
debug!("confirm_object_candidate({})",
obligation.repr(self.tcx()));
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
+ // FIXME skipping binder here seems wrong -- we should
+ // probably flatten the binder from the obligation and the
+ // binder from the object. Have to try to make a broken test
+ // case that results. -nmatsakis
+ let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
let poly_trait_ref = match self_ty.sty {
ty::ty_trait(ref data) => {
data.principal_trait_ref_with_self_ty(self.tcx(), self_ty)
debug!("confirm_fn_pointer_candidate({})",
obligation.repr(self.tcx()));
- let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
+ // ok to skip binder; it is reintroduced below
+ let self_ty = self.infcx.shallow_resolve(*obligation.self_ty().skip_binder());
let sig = ty::ty_fn_sig(self_ty);
- let ty::Binder((trait_ref, _)) =
+ let trait_ref =
util::closure_trait_ref_and_return_type(self.tcx(),
obligation.predicate.def_id(),
self_ty,
sig,
- util::TupleArgumentsFlag::Yes);
- let trait_ref = ty::Binder(trait_ref);
+ util::TupleArgumentsFlag::Yes)
+ .map_bound(|(trait_ref, _)| trait_ref);
try!(self.confirm_poly_trait_refs(obligation.cause.clone(),
obligation.predicate.to_poly_trait_ref(),
///
/// impl Fn(int) for Closure { ... }
///
- /// Now imagine our obligation is `Fn(uint) for Closure`. So far
+ /// Now imagine our obligation is `Fn(usize) for Closure`. So far
/// we have matched the self-type `Closure`. At this point we'll
- /// compare the `int` to `uint` and generate an error.
+ /// compare the `int` to `usize` and generate an error.
///
/// Note that this checking occurs *after* the impl has selected,
/// because these output type parameters should not affect the
/// impl.
fn impl_or_trait_obligations(&mut self,
cause: ObligationCause<'tcx>,
- recursion_depth: uint,
+ recursion_depth: usize,
def_id: ast::DefId, // of impl or trait
substs: &Substs<'tcx>, // for impl or trait
skol_map: infer::SkolemizationMap,
snapshot: &infer::CombinedSnapshot)
-> VecPerParamSpace<PredicateObligation<'tcx>>
{
+ debug!("impl_or_trait_obligations(def_id={})", def_id.repr(self.tcx()));
+
let predicates = ty::lookup_predicates(self.tcx(), def_id);
let predicates = predicates.instantiate(self.tcx(), substs);
let predicates = normalize_with_depth(self, cause.clone(), recursion_depth, &predicates);
ParamCandidate(ref a) => format!("ParamCandidate({})", a.repr(tcx)),
ImplCandidate(a) => format!("ImplCandidate({})", a.repr(tcx)),
DefaultImplCandidate(t) => format!("DefaultImplCandidate({:?})", t),
+ DefaultImplObjectCandidate(t) => format!("DefaultImplObjectCandidate({:?})", t),
ProjectionCandidate => format!("ProjectionCandidate"),
FnPointerCandidate => format!("FnPointerCandidate"),
ObjectCandidate => format!("ObjectCandidate"),
elaborate_trait_refs(tcx, bounds).filter_to_traits()
}
+///////////////////////////////////////////////////////////////////////////
+// Iterator over def-ids of supertraits
+
+pub struct SupertraitDefIds<'cx, 'tcx:'cx> {
+ tcx: &'cx ty::ctxt<'tcx>,
+ stack: Vec<ast::DefId>,
+ visited: FnvHashSet<ast::DefId>,
+}
+
+pub fn supertrait_def_ids<'cx, 'tcx>(tcx: &'cx ty::ctxt<'tcx>,
+ trait_def_id: ast::DefId)
+ -> SupertraitDefIds<'cx, 'tcx>
+{
+ SupertraitDefIds {
+ tcx: tcx,
+ stack: vec![trait_def_id],
+ visited: Some(trait_def_id).into_iter().collect(),
+ }
+}
+
+impl<'cx, 'tcx> Iterator for SupertraitDefIds<'cx, 'tcx> {
+ type Item = ast::DefId;
+
+ fn next(&mut self) -> Option<ast::DefId> {
+ let def_id = match self.stack.pop() {
+ Some(def_id) => def_id,
+ None => { return None; }
+ };
+
+ let predicates = ty::lookup_super_predicates(self.tcx, def_id);
+ let visited = &mut self.visited;
+ self.stack.extend(
+ predicates.predicates
+ .iter()
+ .filter_map(|p| p.to_opt_poly_trait_ref())
+ .map(|t| t.def_id())
+ .filter(|&super_def_id| visited.insert(super_def_id)));
+ Some(def_id)
+ }
+}
+
///////////////////////////////////////////////////////////////////////////
// Other
///////////////////////////////////////////////////////////////////////////
/// See `super::obligations_for_generics`
pub fn predicates_for_generics<'tcx>(tcx: &ty::ctxt<'tcx>,
cause: ObligationCause<'tcx>,
- recursion_depth: uint,
+ recursion_depth: usize,
generic_bounds: &ty::InstantiatedPredicates<'tcx>)
-> VecPerParamSpace<PredicateObligation<'tcx>>
{
pub fn predicate_for_trait_ref<'tcx>(
cause: ObligationCause<'tcx>,
trait_ref: Rc<ty::TraitRef<'tcx>>,
- recursion_depth: uint)
+ recursion_depth: usize)
-> Result<PredicateObligation<'tcx>, ErrorReported>
{
Ok(Obligation {
tcx: &ty::ctxt<'tcx>,
cause: ObligationCause<'tcx>,
trait_def_id: ast::DefId,
- recursion_depth: uint,
+ recursion_depth: usize,
param_ty: Ty<'tcx>)
-> Result<PredicateObligation<'tcx>, ErrorReported>
{
tcx: &ty::ctxt<'tcx>,
cause: ObligationCause<'tcx>,
builtin_bound: ty::BuiltinBound,
- recursion_depth: uint,
+ recursion_depth: usize,
param_ty: Ty<'tcx>)
-> Result<PredicateObligation<'tcx>, ErrorReported>
{
pub fn get_vtable_index_of_object_method<'tcx>(tcx: &ty::ctxt<'tcx>,
object_trait_ref: ty::PolyTraitRef<'tcx>,
trait_def_id: ast::DefId,
- method_offset_in_trait: uint) -> uint {
+ method_offset_in_trait: usize) -> usize {
// We need to figure the "real index" of the method in a
// listing of all the methods of an object. We do this by
// iterating down the supertraits of the object's trait until
use util::ppaux::{Repr, UserString};
use util::common::{memoized, ErrorReported};
use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet};
-use util::nodemap::{FnvHashMap};
+use util::nodemap::FnvHashMap;
use arena::TypedArena;
use std::borrow::{Borrow, Cow};
#[derive(Copy, PartialEq, Eq, Hash)]
pub struct creader_cache_key {
pub cnum: CrateNum,
- pub pos: uint,
- pub len: uint
+ pub pos: usize,
+ pub len: usize
}
#[derive(Clone, PartialEq, RustcDecodable, RustcEncodable)]
#[derive(Clone, PartialEq, Debug)]
pub enum UnsizeKind<'tcx> {
- // [T, ..n] -> [T], the uint field is n.
- UnsizeLength(uint),
+ // [T, ..n] -> [T], the usize field is n.
+ UnsizeLength(usize),
// An unsize coercion applied to the tail field of a struct.
- // The uint is the index of the type parameter which is unsized.
- UnsizeStruct(Box<UnsizeKind<'tcx>>, uint),
+ // The usize is the index of the type parameter which is unsized.
+ UnsizeStruct(Box<UnsizeKind<'tcx>>, usize),
UnsizeVtable(TyTrait<'tcx>, /* the self type of the trait */ Ty<'tcx>),
UnsizeUpcast(Ty<'tcx>),
}
#[derive(Clone, Debug)]
pub struct AutoDerefRef<'tcx> {
- pub autoderefs: uint,
+ pub autoderefs: usize,
pub autoref: Option<AutoRef<'tcx>>
}
#[derive(Clone, Copy, RustcEncodable, RustcDecodable, PartialEq, PartialOrd, Debug)]
pub struct param_index {
pub space: subst::ParamSpace,
- pub index: uint
+ pub index: usize
}
#[derive(Clone, Debug)]
// instantiated with fresh variables at this point.
pub trait_ref: Rc<ty::TraitRef<'tcx>>,
- // index of uint in the list of trait items. Note that this is NOT
+ // index of usize in the list of trait items. Note that this is NOT
// the index into the vtable, because the list of trait items
// includes associated types.
- pub method_num: uint,
+ pub method_num: usize,
/// The impl for the trait from which the method comes. This
/// should only be used for certain linting/heuristic purposes
pub object_trait_id: ast::DefId,
// index of the method to be invoked amongst the trait's items
- pub method_num: uint,
+ pub method_num: usize,
// index into the actual runtime vtable.
// the vtable is formed by concatenating together the method lists of
// the base object trait and all supertraits; this is the index into
// that vtable
- pub vtable_index: uint,
+ pub vtable_index: usize,
}
#[derive(Clone)]
#[derive(Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable, Copy)]
pub enum ExprAdjustment {
NoAdjustment,
- AutoDeref(uint),
+ AutoDeref(usize),
AutoObject
}
}
}
- pub fn autoderef(expr_id: ast::NodeId, autoderef: uint) -> MethodCall {
+ pub fn autoderef(expr_id: ast::NodeId, autoderef: usize) -> MethodCall {
MethodCall {
expr_id: expr_id,
adjustment: AutoDeref(1 + autoderef)
The first argument is the param index (identifying T in the example),
and the second is the bound number (identifying baz)
*/
- vtable_param(param_index, uint),
+ vtable_param(param_index, usize),
/*
Vtable automatically generated for a closure. The def ID is the
pub struct CommonTypes<'tcx> {
pub bool: Ty<'tcx>,
pub char: Ty<'tcx>,
- pub int: Ty<'tcx>,
+ pub isize: Ty<'tcx>,
pub i8: Ty<'tcx>,
pub i16: Ty<'tcx>,
pub i32: Ty<'tcx>,
pub i64: Ty<'tcx>,
- pub uint: Ty<'tcx>,
+ pub usize: Ty<'tcx>,
pub u8: Ty<'tcx>,
pub u16: Ty<'tcx>,
pub u32: Ty<'tcx>,
use middle::ty;
#[derive(Copy)]
struct DebugStat {
- total: uint,
- region_infer: uint,
- ty_infer: uint,
- both_infer: uint,
+ total: usize,
+ region_infer: usize,
+ ty_infer: usize,
+ both_infer: usize,
}
pub fn go(tcx: &ty::ctxt) {
///
/// So, for example, consider a type like the following, which has two binders:
///
-/// for<'a> fn(x: for<'b> fn(&'a int, &'b int))
+/// for<'a> fn(x: for<'b> fn(&'a isize, &'b isize))
/// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ outer scope
/// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~ inner scope
///
impl<'tcx> PolyFnSig<'tcx> {
pub fn inputs(&self) -> ty::Binder<Vec<Ty<'tcx>>> {
- ty::Binder(self.0.inputs.clone())
+ self.map_bound_ref(|fn_sig| fn_sig.inputs.clone())
}
- pub fn input(&self, index: uint) -> ty::Binder<Ty<'tcx>> {
- ty::Binder(self.0.inputs[index])
+ pub fn input(&self, index: usize) -> ty::Binder<Ty<'tcx>> {
+ self.map_bound_ref(|fn_sig| fn_sig.inputs[index])
}
pub fn output(&self) -> ty::Binder<FnOutput<'tcx>> {
- ty::Binder(self.0.output.clone())
+ self.map_bound_ref(|fn_sig| fn_sig.output.clone())
}
pub fn variadic(&self) -> bool {
- self.0.variadic
+ self.skip_binder().variadic
}
}
/// regions (and perhaps later types) in a higher-ranked setting. In
/// particular, imagine a type like this:
///
-/// for<'a> fn(for<'b> fn(&'b int, &'a int), &'a char)
+/// for<'a> fn(for<'b> fn(&'b isize, &'a isize), &'a char)
/// ^ ^ | | |
/// | | | | |
/// | +------------+ 1 | |
/// count the number of binders, inside out. Some examples should help
/// clarify what I mean.
///
-/// Let's start with the reference type `&'b int` that is the first
+/// Let's start with the reference type `&'b isize` that is the first
/// argument to the inner function. This region `'b` is assigned a De
/// Bruijn index of 1, meaning "the innermost binder" (in this case, a
/// fn). The region `'a` that appears in the second argument type (`&'a
-/// int`) would then be assigned a De Bruijn index of 2, meaning "the
+/// isize`) would then be assigned a De Bruijn index of 2, meaning "the
/// second-innermost binder". (These indices are written on the arrays
/// in the diagram).
///
/// implicit closure bindings. It is needed when you the closure
/// is borrowing or mutating a mutable referent, e.g.:
///
- /// let x: &mut int = ...;
+ /// let x: &mut isize = ...;
/// let y = || *x += 5;
///
/// If we were to try to translate this closure into a more explicit
/// form, we'd encounter an error with the code as written:
///
- /// struct Env { x: & &mut int }
- /// let x: &mut int = ...;
+ /// struct Env { x: & &mut isize }
+ /// let x: &mut isize = ...;
/// let y = (&mut Env { &x }, fn_ptr); // Closure is pair of env and fn
/// fn fn_ptr(env: &mut Env) { **env.x += 5; }
///
/// in an aliasable location. To solve, you'd have to translate with
/// an `&mut` borrow:
///
- /// struct Env { x: & &mut int }
- /// let x: &mut int = ...;
+ /// struct Env { x: & &mut isize }
+ /// let x: &mut isize = ...;
/// let y = (&mut Env { &mut x }, fn_ptr); // changed from &x to &mut x
/// fn fn_ptr(env: &mut Env) { **env.x += 5; }
///
ty_enum(DefId, &'tcx Substs<'tcx>),
ty_uniq(Ty<'tcx>),
ty_str,
- ty_vec(Ty<'tcx>, Option<uint>), // Second field is length.
+ ty_vec(Ty<'tcx>, Option<usize>), // Second field is length.
ty_ptr(mt<'tcx>),
ty_rptr(&'tcx Region, mt<'tcx>),
}
/// Binder is a binder for higher-ranked lifetimes. It is part of the
-/// compiler's representation for things like `for<'a> Fn(&'a int)`
+/// compiler's representation for things like `for<'a> Fn(&'a isize)`
/// (which would be represented by the type `PolyTraitRef ==
/// Binder<TraitRef>`). Note that when we skolemize, instantiate,
/// erase, or otherwise "discharge" these bound regions, we change the
pub fn skip_binder(&self) -> &T {
&self.0
}
+
+ pub fn as_ref(&self) -> Binder<&T> {
+ ty::Binder(&self.0)
+ }
+
+ pub fn map_bound_ref<F,U>(&self, f: F) -> Binder<U>
+ where F: FnOnce(&T) -> U
+ {
+ self.as_ref().map_bound(f)
+ }
+
+ pub fn map_bound<F,U>(self, f: F) -> Binder<U>
+ where F: FnOnce(T) -> U
+ {
+ ty::Binder(f(self.0))
+ }
}
#[derive(Clone, Copy, PartialEq)]
terr_ptr_mutability,
terr_ref_mutability,
terr_vec_mutability,
- terr_tuple_size(expected_found<uint>),
- terr_fixed_array_size(expected_found<uint>),
- terr_ty_param_size(expected_found<uint>),
+ terr_tuple_size(expected_found<usize>),
+ terr_fixed_array_size(expected_found<usize>),
+ terr_ty_param_size(expected_found<usize>),
terr_arg_count,
terr_regions_does_not_outlive(Region, Region),
terr_regions_not_same(Region, Region),
terr_cyclic_ty,
terr_convergence_mismatch(expected_found<bool>),
terr_projection_name_mismatched(expected_found<ast::Name>),
- terr_projection_bounds_length(expected_found<uint>),
+ terr_projection_bounds_length(expected_found<usize>),
}
/// Bounds suitable for a named type parameter like `A` in `fn foo<A>`
#[derive(Clone, RustcEncodable, PartialEq, Eq, RustcDecodable, Hash,
Debug, Copy)]
-#[repr(uint)]
+#[repr(usize)]
pub enum BuiltinBound {
BoundSend,
BoundSized,
}
impl CLike for BuiltinBound {
- fn to_usize(&self) -> uint {
- *self as uint
+ fn to_usize(&self) -> usize {
+ *self as usize
}
- fn from_usize(v: uint) -> BuiltinBound {
+ fn from_usize(v: usize) -> BuiltinBound {
unsafe { mem::transmute(v) }
}
}
impl<'tcx> ToPolyTraitRef<'tcx> for PolyTraitPredicate<'tcx> {
fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx> {
- // We are just preserving the binder levels here
- ty::Binder(self.0.trait_ref.clone())
+ self.map_bound_ref(|trait_pred| trait_pred.trait_ref.clone())
}
}
///
/// Here, the `GenericPredicates` for `Foo` would contain a list of bounds like
/// `[[], [U:Bar<T>]]`. Now if there were some particular reference
-/// like `Foo<int,uint>`, then the `InstantiatedPredicates` would be `[[],
-/// [uint:Bar<int>]]`.
+/// like `Foo<isize,usize>`, then the `InstantiatedPredicates` would be `[[],
+/// [usize:Bar<isize>]]`.
#[derive(Clone, Debug)]
pub struct InstantiatedPredicates<'tcx> {
pub predicates: VecPerParamSpace<Predicate<'tcx>>,
bool: intern_ty(arena, interner, ty_bool),
char: intern_ty(arena, interner, ty_char),
err: intern_ty(arena, interner, ty_err),
- int: intern_ty(arena, interner, ty_int(ast::TyIs(false))),
+ isize: intern_ty(arena, interner, ty_int(ast::TyIs)),
i8: intern_ty(arena, interner, ty_int(ast::TyI8)),
i16: intern_ty(arena, interner, ty_int(ast::TyI16)),
i32: intern_ty(arena, interner, ty_int(ast::TyI32)),
i64: intern_ty(arena, interner, ty_int(ast::TyI64)),
- uint: intern_ty(arena, interner, ty_uint(ast::TyUs(false))),
+ usize: intern_ty(arena, interner, ty_uint(ast::TyUs)),
u8: intern_ty(arena, interner, ty_uint(ast::TyU8)),
u16: intern_ty(arena, interner, ty_uint(ast::TyU16)),
u32: intern_ty(arena, interner, ty_uint(ast::TyU32)),
pub fn mk_mach_int<'tcx>(tcx: &ctxt<'tcx>, tm: ast::IntTy) -> Ty<'tcx> {
match tm {
- ast::TyIs(_) => tcx.types.int,
+ ast::TyIs => tcx.types.isize,
ast::TyI8 => tcx.types.i8,
ast::TyI16 => tcx.types.i16,
ast::TyI32 => tcx.types.i32,
pub fn mk_mach_uint<'tcx>(tcx: &ctxt<'tcx>, tm: ast::UintTy) -> Ty<'tcx> {
match tm {
- ast::TyUs(_) => tcx.types.uint,
+ ast::TyUs => tcx.types.usize,
ast::TyU8 => tcx.types.u8,
ast::TyU16 => tcx.types.u16,
ast::TyU32 => tcx.types.u32,
mk_ptr(cx, mt {ty: mk_nil(cx), mutbl: ast::MutImmutable})
}
-pub fn mk_vec<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, sz: Option<uint>) -> Ty<'tcx> {
+pub fn mk_vec<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, sz: Option<usize>) -> Ty<'tcx> {
mk_t(cx, ty_vec(ty, sz))
}
mk_tup(cx, Vec::new())
}
+pub fn mk_bool<'tcx>(cx: &ctxt<'tcx>) -> Ty<'tcx> {
+ mk_t(cx, ty_bool)
+}
+
pub fn mk_bare_fn<'tcx>(cx: &ctxt<'tcx>,
opt_def_id: Option<ast::DefId>,
fty: &'tcx BareFnTy<'tcx>) -> Ty<'tcx> {
/// structs or variants. For example:
///
/// ```notrust
- /// int => { int }
- /// Foo<Bar<int>> => { Foo<Bar<int>>, Bar<int>, int }
- /// [int] => { [int], int }
+ /// isize => { isize }
+ /// Foo<Bar<isize>> => { Foo<Bar<isize>>, Bar<isize>, isize }
+ /// [isize] => { [isize], isize }
/// ```
pub fn walk(&'tcx self) -> TypeWalker<'tcx> {
TypeWalker::new(self)
/// example:
///
/// ```notrust
- /// int => { }
- /// Foo<Bar<int>> => { Bar<int>, int }
- /// [int] => { int }
+ /// isize => { }
+ /// Foo<Bar<isize>> => { Bar<isize>, isize }
+ /// [isize] => { isize }
/// ```
pub fn walk_children(&'tcx self) -> TypeWalker<'tcx> {
// Walks type reachable from `self` but not `self
}
}
-pub fn simd_size(cx: &ctxt, ty: Ty) -> uint {
+pub fn simd_size(cx: &ctxt, ty: Ty) -> usize {
match ty.sty {
ty_struct(did, _) => {
let fields = lookup_struct_fields(cx, did);
/// Returns true if this type is a floating point type and false otherwise.
pub fn type_is_floating_point(ty: Ty) -> bool {
match ty.sty {
- ty_float(_) => true,
- _ => false,
+ ty_float(_) |
+ ty_infer(FloatVar(_)) =>
+ true,
+
+ _ =>
+ false,
}
}
cache.insert(ty, TC::None);
let result = match ty.sty {
- // uint and int are ffi-unsafe
- ty_uint(ast::TyUs(_)) | ty_int(ast::TyIs(_)) => {
+ // usize and isize are ffi-unsafe
+ ty_uint(ast::TyUs) | ty_int(ast::TyIs) => {
TC::ReachesFfiUnsafe
}
pub fn type_is_uint(ty: Ty) -> bool {
match ty.sty {
- ty_infer(IntVar(_)) | ty_uint(ast::TyUs(_)) => true,
+ ty_infer(IntVar(_)) | ty_uint(ast::TyUs) => true,
_ => false
}
}
pub fn type_is_machine(ty: Ty) -> bool {
match ty.sty {
- ty_int(ast::TyIs(_)) | ty_uint(ast::TyUs(_)) => false,
+ ty_int(ast::TyIs) | ty_uint(ast::TyUs) => false,
ty_int(..) | ty_uint(..) | ty_float(..) => true,
_ => false
}
/// For an enum `t`, `variant` is None only if `t` is a univariant enum.
pub fn positional_element_ty<'tcx>(cx: &ctxt<'tcx>,
ty: Ty<'tcx>,
- i: uint,
+ i: usize,
variant: Option<ast::DefId>) -> Option<Ty<'tcx>> {
match (&ty.sty, variant) {
// adjustments. See `expr_ty_adjusted()` instead.
//
// NB (2): This type doesn't provide type parameter substitutions; e.g. if you
-// ask for the type of "id" in "id(3)", it will return "fn(&int) -> int"
-// instead of "fn(ty) -> T with T = int".
+// ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize"
+// instead of "fn(ty) -> T with T = isize".
pub fn expr_ty<'tcx>(cx: &ctxt<'tcx>, expr: &ast::Expr) -> Ty<'tcx> {
return node_id_to_type(cx, expr.id);
}
}
pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field])
- -> uint {
+ -> usize {
let mut i = 0;
for f in fields { if f.name == name { return i; } i += 1; }
tcx.sess.bug(&format!(
}
pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem])
- -> Option<uint> {
+ -> Option<usize> {
trait_items.iter().position(|m| m.name() == id)
}
v
}
-pub fn trait_item<'tcx>(cx: &ctxt<'tcx>, trait_did: ast::DefId, idx: uint)
+pub fn trait_item<'tcx>(cx: &ctxt<'tcx>, trait_did: ast::DefId, idx: usize)
-> ImplOrTraitItem<'tcx> {
let method_def_id = (*ty::trait_item_def_ids(cx, trait_did))[idx].def_id();
impl_or_trait_item(cx, method_def_id)
pub fn associated_type_parameter_index(cx: &ctxt,
trait_def: &TraitDef,
associated_type_id: ast::DefId)
- -> uint {
+ -> usize {
for type_parameter_def in trait_def.generics.types.iter() {
if type_parameter_def.def_id == associated_type_id {
- return type_parameter_def.index as uint
+ return type_parameter_def.index as usize
}
}
cx.sess.bug("couldn't find associated type parameter index")
pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId)
-> Rc<Vec<Rc<VariantInfo<'tcx>>>> {
- use std::num::Int; // For checked_add
memoized(&cx.enum_var_cache, id, |id: ast::DefId| {
if ast::LOCAL_CRATE != id.krate {
Rc::new(csearch::get_enum_variants(cx, id))
}
}
-pub fn is_binopable<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>, op: ast::BinOp) -> bool {
- #![allow(non_upper_case_globals)]
- const tycat_other: int = 0;
- const tycat_bool: int = 1;
- const tycat_char: int = 2;
- const tycat_int: int = 3;
- const tycat_float: int = 4;
- const tycat_raw_ptr: int = 6;
-
- const opcat_add: int = 0;
- const opcat_sub: int = 1;
- const opcat_mult: int = 2;
- const opcat_shift: int = 3;
- const opcat_rel: int = 4;
- const opcat_eq: int = 5;
- const opcat_bit: int = 6;
- const opcat_logic: int = 7;
- const opcat_mod: int = 8;
-
- fn opcat(op: ast::BinOp) -> int {
- match op.node {
- ast::BiAdd => opcat_add,
- ast::BiSub => opcat_sub,
- ast::BiMul => opcat_mult,
- ast::BiDiv => opcat_mult,
- ast::BiRem => opcat_mod,
- ast::BiAnd => opcat_logic,
- ast::BiOr => opcat_logic,
- ast::BiBitXor => opcat_bit,
- ast::BiBitAnd => opcat_bit,
- ast::BiBitOr => opcat_bit,
- ast::BiShl => opcat_shift,
- ast::BiShr => opcat_shift,
- ast::BiEq => opcat_eq,
- ast::BiNe => opcat_eq,
- ast::BiLt => opcat_rel,
- ast::BiLe => opcat_rel,
- ast::BiGe => opcat_rel,
- ast::BiGt => opcat_rel
- }
- }
-
- fn tycat<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> int {
- if type_is_simd(cx, ty) {
- return tycat(cx, simd_type(cx, ty))
- }
- match ty.sty {
- ty_char => tycat_char,
- ty_bool => tycat_bool,
- ty_int(_) | ty_uint(_) | ty_infer(IntVar(_)) => tycat_int,
- ty_float(_) | ty_infer(FloatVar(_)) => tycat_float,
- ty_ptr(_) => tycat_raw_ptr,
- _ => tycat_other
- }
- }
-
- const t: bool = true;
- const f: bool = false;
-
- let tbl = [
- // +, -, *, shift, rel, ==, bit, logic, mod
- /*other*/ [f, f, f, f, f, f, f, f, f],
- /*bool*/ [f, f, f, f, t, t, t, t, f],
- /*char*/ [f, f, f, f, t, t, f, f, f],
- /*int*/ [t, t, t, t, t, t, t, f, t],
- /*float*/ [t, t, t, f, t, t, f, f, f],
- /*bot*/ [t, t, t, t, t, t, t, t, t],
- /*raw ptr*/ [f, f, f, f, t, t, f, f, f]];
-
- return tbl[tycat(cx, ty) as uint ][opcat(op) as uint];
-}
-
// Returns the repeat count for a repeating vector expression.
-pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint {
- match const_eval::eval_const_expr_partial(tcx, count_expr, Some(tcx.types.uint)) {
+pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> usize {
+ match const_eval::eval_const_expr_partial(tcx, count_expr, Some(tcx.types.usize)) {
Ok(val) => {
let found = match val {
- const_eval::const_uint(count) => return count as uint,
- const_eval::const_int(count) if count >= 0 => return count as uint,
+ const_eval::const_uint(count) => return count as usize,
+ const_eval::const_int(count) if count >= 0 => return count as usize,
const_eval::const_int(_) => "negative integer",
const_eval::const_float(_) => "float",
const_eval::const_str(_) => "string",
pub fn count_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
value: &Binder<T>)
- -> uint
+ -> usize
where T : TypeFoldable<'tcx> + Repr<'tcx>
{
let (_, skol_map) = replace_late_bound_regions(tcx, value, |_| ty::ReStatic);
count_late_bound_regions(tcx, value) > 0
}
+/// Flattens two binding levels into one. So `for<'a> for<'b> Foo`
+/// becomes `for<'a,'b> Foo`.
+pub fn flatten_late_bound_regions<'tcx, T>(
+ tcx: &ty::ctxt<'tcx>,
+ bound2_value: &Binder<Binder<T>>)
+ -> Binder<T>
+ where T: TypeFoldable<'tcx> + Repr<'tcx>
+{
+ let bound0_value = bound2_value.skip_binder().skip_binder();
+ let value = ty_fold::fold_regions(tcx, bound0_value, |region, current_depth| {
+ match region {
+ ty::ReLateBound(debruijn, br) if debruijn.depth >= current_depth => {
+ // should be true if no escaping regions from bound2_value
+ assert!(debruijn.depth - current_depth <= 1);
+ ty::ReLateBound(DebruijnIndex::new(current_depth), br)
+ }
+ _ => {
+ region
+ }
+ }
+ });
+ Binder(value)
+}
+
pub fn no_late_bound_regions<'tcx, T>(
tcx: &ty::ctxt<'tcx>,
value: &Binder<T>)
///
/// The chief purpose of this function is to canonicalize regions so that two
/// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become
-/// structurally identical. For example, `for<'a, 'b> fn(&'a int, &'b int)` and
-/// `for<'a, 'b> fn(&'b int, &'a int)` will become identical after anonymization.
+/// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and
+/// `for<'a, 'b> fn(&'b isize, &'a isize)` will become identical after anonymization.
pub fn anonymize_late_bound_regions<'tcx, T>(
tcx: &ctxt<'tcx>,
sig: &Binder<T>)
}
}
+impl<'tcx,P:RegionEscape> RegionEscape for traits::Obligation<'tcx,P> {
+ fn has_regions_escaping_depth(&self, depth: u32) -> bool {
+ self.predicate.has_regions_escaping_depth(depth)
+ }
+}
+
impl<'tcx> RegionEscape for TraitRef<'tcx> {
fn has_regions_escaping_depth(&self, depth: u32) -> bool {
self.substs.types.iter().any(|t| t.has_regions_escaping_depth(depth)) ||
pub struct TypeWalker<'tcx> {
stack: Vec<Ty<'tcx>>,
- last_subtree: uint,
+ last_subtree: usize,
}
impl<'tcx> TypeWalker<'tcx> {
/// Skips the subtree of types corresponding to the last type
/// returned by `next()`.
///
- /// Example: Imagine you are walking `Foo<Bar<int>, uint>`.
+ /// Example: Imagine you are walking `Foo<Bar<int>, usize>`.
///
/// ```
/// let mut iter: TypeWalker = ...;
/// iter.next(); // yields Foo
/// iter.next(); // yields Bar<int>
/// iter.skip_current_subtree(); // skips int
- /// iter.next(); // yields uint
+ /// iter.next(); // yields usize
/// ```
pub fn skip_current_subtree(&mut self) {
self.stack.truncate(self.last_subtree);
use std::dynamic_lib::DynamicLibrary;
use std::env;
use std::mem;
-
-#[allow(deprecated)]
-use std::old_path;
-
use std::path::PathBuf;
use syntax::ast;
use syntax::codemap::{Span, COMMAND_LINE_SP};
symbol: String) -> PluginRegistrarFun {
// Make sure the path contains a / or the linker will search for it.
let path = env::current_dir().unwrap().join(&path);
- let path = old_path::Path::new(path.to_str().unwrap());
let lib = match DynamicLibrary::open(Some(&path)) {
Ok(lib) => lib,
//! #![plugin(myplugin)]
//! ```
//!
-//! See [the compiler plugin guide](../../guide-plugin.html)
+//! See the [Plugins Chapter](../../book/plugins.html) of the book
//! for more examples.
pub use self::registry::Registry;
use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
use syntax::ext::base::{IdentTT, Decorator, Modifier, MultiModifier, MacroRulesTT};
-use syntax::ext::base::{MacroExpanderFn};
+use syntax::ext::base::MacroExpanderFn;
use syntax::codemap::Span;
use syntax::parse::token;
use syntax::ptr::P;
}
}
- fn parse_uint(slot: &mut uint, v: Option<&str>) -> bool {
+ fn parse_uint(slot: &mut usize, v: Option<&str>) -> bool {
match v.and_then(|s| s.parse().ok()) {
Some(i) => { *slot = i; true },
None => false
}
}
- fn parse_opt_uint(slot: &mut Option<uint>, v: Option<&str>) -> bool {
+ fn parse_opt_uint(slot: &mut Option<usize>, v: Option<&str>) -> bool {
match v {
Some(s) => { *slot = s.parse().ok(); slot.is_some() }
None => { *slot = None; true }
"metadata to mangle symbol names with"),
extra_filename: String = ("".to_string(), parse_string,
"extra data to put in each output filename"),
- codegen_units: uint = (1, parse_uint,
+ codegen_units: usize = (1, parse_uint,
"divide crate into N units to optimize in parallel"),
remark: Passes = (SomePasses(Vec::new()), parse_passes,
"print remarks for these optimization passes (space separated, or \"all\")"),
no_stack_check: bool = (false, parse_bool,
"disable checks for stack exhaustion (a memory-safety hazard!)"),
- debuginfo: Option<uint> = (None, parse_opt_uint,
+ debuginfo: Option<usize> = (None, parse_opt_uint,
"debug info emission level, 0 = no debug info, 1 = line tables only, \
2 = full debug info with variable and type information"),
- opt_level: Option<uint> = (None, parse_opt_uint,
+ opt_level: Option<usize> = (None, parse_opt_uint,
"Optimize with possible levels 0-3"),
debug_assertions: Option<bool> = (None, parse_opt_bool,
"explicitly enable the cfg(debug_assertions) directive"),
"Print the size of enums and their variants"),
force_overflow_checks: Option<bool> = (None, parse_opt_bool,
"Force overflow checks on or off"),
+ force_dropflag_checks: Option<bool> = (None, parse_opt_bool,
+ "Force drop flag checks on or off"),
}
pub fn default_lib_output() -> CrateType {
let libs = matches.opt_strs("l").into_iter().map(|s| {
let mut parts = s.splitn(1, '=');
let kind = parts.next().unwrap();
- if let Some(name) = parts.next() {
- let kind = match kind {
- "dylib" => cstore::NativeUnknown,
- "framework" => cstore::NativeFramework,
- "static" => cstore::NativeStatic,
- s => {
- early_error(&format!("unknown library kind `{}`, expected \
- one of dylib, framework, or static",
- s));
- }
- };
- return (name.to_string(), kind)
- }
-
- // FIXME(acrichto) remove this once crates have stopped using it, this
- // is deprecated behavior now.
- let mut parts = s.rsplitn(1, ':');
- let kind = parts.next().unwrap();
let (name, kind) = match (parts.next(), kind) {
(None, name) |
(Some(name), "dylib") => (name, cstore::NativeUnknown),
/// The maximum recursion limit for potentially infinitely recursive
/// operations such as auto-dereference and monomorphization.
- pub recursion_limit: Cell<uint>,
+ pub recursion_limit: Cell<usize>,
pub can_print_warnings: bool
}
}
self.diagnostic().handler().err(msg)
}
- pub fn err_count(&self) -> uint {
+ pub fn err_count(&self) -> usize {
self.diagnostic().handler().err_count()
}
pub fn has_errors(&self) -> bool {
pub fn time<T, U, F>(do_it: bool, what: &str, u: U, f: F) -> T where
F: FnOnce(U) -> T,
{
- thread_local!(static DEPTH: Cell<uint> = Cell::new(0));
+ thread_local!(static DEPTH: Cell<usize> = Cell::new(0));
if !do_it { return f(u); }
let old = DEPTH.with(|slot| {
/// # Examples
/// ```
/// struct Context {
-/// cache: RefCell<HashMap<uint, uint>>
+/// cache: RefCell<HashMap<usize, usize>>
/// }
///
-/// fn factorial(ctxt: &Context, n: uint) -> uint {
+/// fn factorial(ctxt: &Context, n: usize) -> usize {
/// memoized(&ctxt.cache, n, |n| match n {
/// 0 | 1 => n,
/// _ => factorial(ctxt, n - 2) + factorial(ctxt, n - 1)
use std::cmp;
-pub fn lev_distance(me: &str, t: &str) -> uint {
+pub fn lev_distance(me: &str, t: &str) -> usize {
if me.is_empty() { return t.chars().count(); }
if t.is_empty() { return me.chars().count(); }
#![allow(non_snake_case)]
-use std::collections::hash_state::{DefaultState};
+use std::collections::hash_state::DefaultState;
use std::collections::{HashMap, HashSet};
use std::default::Default;
use std::hash::{Hasher, Hash};
use middle::ty::{ty_bool, ty_char, ty_struct, ty_enum};
use middle::ty::{ty_err, ty_str, ty_vec, ty_float, ty_bare_fn};
use middle::ty::{ty_param, ty_ptr, ty_rptr, ty_tup};
-use middle::ty::{ty_closure};
+use middle::ty::ty_closure;
use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer};
use middle::ty;
use middle::ty_fold::TypeFoldable;
CommittedSnapshot,
/// New variable with given index was created.
- NewElem(uint),
+ NewElem(usize),
/// Variable with given index was changed *from* the given value.
- SetElem(uint, D::Value),
+ SetElem(usize, D::Value),
/// Extensible set of actions
Other(D::Undo)
// Snapshots are tokens that should be created/consumed linearly.
pub struct Snapshot {
// Length of the undo log at the time the snapshot was taken.
- length: uint,
+ length: usize,
}
pub trait SnapshotVecDelegate {
}
}
- pub fn push(&mut self, elem: D::Value) -> uint {
+ pub fn push(&mut self, elem: D::Value) -> usize {
let len = self.values.len();
self.values.push(elem);
len
}
- pub fn get<'a>(&'a self, index: uint) -> &'a D::Value {
+ pub fn get<'a>(&'a self, index: usize) -> &'a D::Value {
&self.values[index]
}
/// Returns a mutable pointer into the vec; whatever changes you make here cannot be undone
/// automatically, so you should be sure call `record()` with some sort of suitable undo
/// action.
- pub fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut D::Value {
+ pub fn get_mut<'a>(&'a mut self, index: usize) -> &'a mut D::Value {
&mut self.values[index]
}
/// Updates the element at the given index. The old value will saved (and perhaps restored) if
/// a snapshot is active.
- pub fn set(&mut self, index: uint, new_elem: D::Value) {
+ pub fn set(&mut self, index: usize, new_elem: D::Value) {
let old_elem = mem::replace(&mut self.values[index], new_elem);
if self.in_snapshot() {
self.undo_log.push(SetElem(index, old_elem));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub const BOX_FIELD_DROP_GLUE: uint = 1;
-pub const BOX_FIELD_BODY: uint = 4;
+pub const BOX_FIELD_DROP_GLUE: usize = 1;
+pub const BOX_FIELD_BODY: usize = 4;
/// The first half of a fat pointer.
/// - For a closure, this is the code address.
/// - For an object or trait instance, this is the address of the box.
/// - For a slice, this is the base address.
-pub const FAT_PTR_ADDR: uint = 0;
+pub const FAT_PTR_ADDR: usize = 0;
/// The second half of a fat pointer.
/// - For a closure, this is the address of the environment.
/// - For an object or trait instance, this is the address of the vtable.
/// - For a slice, this is the length.
-pub const FAT_PTR_EXTRA: uint = 1;
+pub const FAT_PTR_EXTRA: usize = 1;
// Don't allow the total size of `args` to grow beyond 32,000 bytes.
// Windows will raise an error if the argument string is longer than
// 32,768, and we leave a bit of extra space for the program name.
- const ARG_LENGTH_LIMIT: uint = 32_000;
+ const ARG_LENGTH_LIMIT: usize = 32_000;
for member_name in &self.members {
let len = member_name.to_string_lossy().len();
#![feature(collections)]
#![feature(core)]
#![feature(old_fs)]
-#![feature(int_uint)]
#![feature(io)]
#![feature(old_io)]
#![feature(old_path)]
fn add_bytes_to_bits<T: Int + ToBits>(bits: T, bytes: T) -> T {
let (new_high_bits, new_low_bits) = bytes.to_bits();
- if new_high_bits > Int::zero() {
+ if new_high_bits > T::zero() {
panic!("numeric overflow occurred.")
}
/// Zero the buffer up until the specified index. The buffer position currently must not be
/// greater than that index.
- fn zero_until(&mut self, idx: uint);
+ fn zero_until(&mut self, idx: usize);
/// Get a slice of the buffer of the specified size. There must be at least that many bytes
/// remaining in the buffer.
- fn next<'s>(&'s mut self, len: uint) -> &'s mut [u8];
+ fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8];
/// Get the current buffer. The buffer must already be full. This clears the buffer as well.
fn full_buffer<'s>(&'s mut self) -> &'s [u8];
/// Get the current position of the buffer.
- fn position(&self) -> uint;
+ fn position(&self) -> usize;
/// Get the number of bytes remaining in the buffer until it is full.
- fn remaining(&self) -> uint;
+ fn remaining(&self) -> usize;
/// Get the size of the buffer
- fn size(&self) -> uint;
+ fn size(&self) -> usize;
}
/// A FixedBuffer of 64 bytes useful for implementing Sha256 which has a 64 byte blocksize.
struct FixedBuffer64 {
buffer: [u8; 64],
- buffer_idx: uint,
+ buffer_idx: usize,
}
impl FixedBuffer64 {
let buffer_remaining = size - self.buffer_idx;
if input.len() >= buffer_remaining {
copy_memory(
- &mut self.buffer[self.buffer_idx..size],
- &input[..buffer_remaining]);
+ &input[..buffer_remaining],
+ &mut self.buffer[self.buffer_idx..size]);
self.buffer_idx = 0;
func(&self.buffer);
i += buffer_remaining;
} else {
copy_memory(
- &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()],
- input);
+ input,
+ &mut self.buffer[self.buffer_idx..self.buffer_idx + input.len()]);
self.buffer_idx += input.len();
return;
}
// be empty.
let input_remaining = input.len() - i;
copy_memory(
- &mut self.buffer[..input_remaining],
- &input[i..]);
+ &input[i..],
+ &mut self.buffer[..input_remaining]);
self.buffer_idx += input_remaining;
}
self.buffer_idx = 0;
}
- fn zero_until(&mut self, idx: uint) {
+ fn zero_until(&mut self, idx: usize) {
assert!(idx >= self.buffer_idx);
self.buffer[self.buffer_idx..idx].set_memory(0);
self.buffer_idx = idx;
}
- fn next<'s>(&'s mut self, len: uint) -> &'s mut [u8] {
+ fn next<'s>(&'s mut self, len: usize) -> &'s mut [u8] {
self.buffer_idx += len;
return &mut self.buffer[self.buffer_idx - len..self.buffer_idx];
}
return &self.buffer[..64];
}
- fn position(&self) -> uint { self.buffer_idx }
+ fn position(&self) -> usize { self.buffer_idx }
- fn remaining(&self) -> uint { 64 - self.buffer_idx }
+ fn remaining(&self) -> usize { 64 - self.buffer_idx }
- fn size(&self) -> uint { 64 }
+ fn size(&self) -> usize { 64 }
}
/// The StandardPadding trait adds a method useful for Sha256 to a FixedBuffer struct.
/// guaranteed to have exactly rem remaining bytes when it returns. If there are not at least
/// rem bytes available, the buffer will be zero padded, processed, cleared, and then filled
/// with zeros again until only rem bytes are remaining.
- fn standard_padding<F>(&mut self, rem: uint, func: F) where F: FnMut(&[u8]);
+ fn standard_padding<F>(&mut self, rem: usize, func: F) where F: FnMut(&[u8]);
}
impl <T: FixedBuffer> StandardPadding for T {
- fn standard_padding<F>(&mut self, rem: uint, mut func: F) where F: FnMut(&[u8]) {
+ fn standard_padding<F>(&mut self, rem: usize, mut func: F) where F: FnMut(&[u8]) {
let size = self.size();
self.next(1)[0] = 128;
fn reset(&mut self);
/// Get the output size in bits.
- fn output_bits(&self) -> uint;
+ fn output_bits(&self) -> usize;
/// Convenience function that feeds a string into a digest.
///
self.engine.reset(&H256);
}
- fn output_bits(&self) -> uint { 256 }
+ fn output_bits(&self) -> usize { 256 }
}
static H256: [u32; 8] = [
use self::rand::isaac::IsaacRng;
use serialize::hex::FromHex;
use std::iter::repeat;
- use std::num::Int;
+ use std::u64;
use super::{Digest, Sha256, FixedBuffer};
// A normal addition - no overflow occurs
#[test]
#[should_panic]
fn test_add_bytes_to_bits_overflow() {
- super::add_bytes_to_bits::<u64>(Int::max_value(), 1);
+ super::add_bytes_to_bits::<u64>(u64::MAX, 1);
}
struct Test {
/// Feed 1,000,000 'a's into the digest with varying input sizes and check that the result is
/// correct.
- fn test_digest_1million_random<D: Digest>(digest: &mut D, blocksize: uint, expected: &str) {
+ fn test_digest_1million_random<D: Digest>(digest: &mut D, blocksize: usize, expected: &str) {
let total_size = 1000000;
let buffer: Vec<u8> = repeat('a' as u8).take(blocksize * 2).collect();
let mut rng = IsaacRng::new_unseeded();
digest.reset();
while count < total_size {
- let next: uint = rng.gen_range(0, 2 * blocksize + 1);
+ let next: usize = rng.gen_range(0, 2 * blocksize + 1);
let remaining = total_size - count;
let size = if next > remaining { remaining } else { next };
digest.input(&buffer[..size]);
SawExprLoop(Option<token::InternedString>),
SawExprField(token::InternedString),
- SawExprTupField(uint),
+ SawExprTupField(usize),
SawExprBreak(Option<token::InternedString>),
SawExprAgain(Option<token::InternedString>),
/// particular running dsymutil and some other stuff like `-dead_strip`. Defaults to false.
pub is_like_osx: bool,
/// Whether the target toolchain is like Windows'. Only useful for compiling against Windows,
- /// only realy used for figuring out how to find libraries, since Windows uses its own
+ /// only really used for figuring out how to find libraries, since Windows uses its own
/// library naming convention. Defaults to false.
pub is_like_windows: bool,
/// Whether the target toolchain is like Android's. Only useful for compiling against Android.
// be enough to dissuade an attacker from trying to preemptively create names
// of that length, but not so huge that we unnecessarily drain the random number
// generator of entropy.
-const NUM_RAND_CHARS: uint = 12;
+const NUM_RAND_CHARS: usize = 12;
impl TempDir {
/// Attempts to make a temporary directory inside of `tmpdir` whose name
return true;
}
- pub fn loans_generated_by(&self, scope: region::CodeExtent) -> Vec<uint> {
+ pub fn loans_generated_by(&self, scope: region::CodeExtent) -> Vec<usize> {
//! Returns a vector of the loans that are generated as
//! we enter `scope`.
/// let a: int;
/// a = 10; // ok, even though a is uninitialized
///
- /// struct Point { x: uint, y: uint }
+ /// struct Point { x: usize, y: usize }
/// let p: Point;
/// p.x = 22; // ok, even though `p` is uninitialized
///
cmt: mc::cmt<'tcx>)
-> bool {
match cmt.freely_aliasable(this.tcx()) {
- None => {
+ mc::Aliasability::NonAliasable => {
return true;
}
- Some(mc::AliasableStaticMut(..)) => {
+ mc::Aliasability::FreelyAliasable(mc::AliasableStaticMut(..)) => {
return true;
}
- Some(cause) => {
+ mc::Aliasability::ImmutableUnique(_) => {
+ this.bccx.report_aliasability_violation(
+ span,
+ MutabilityViolation,
+ mc::AliasableReason::UnaliasableImmutable);
+ return false;
+ }
+ mc::Aliasability::FreelyAliasable(cause) => {
this.bccx.report_aliasability_violation(
span,
MutabilityViolation,
use self::Fragment::*;
use borrowck::InteriorKind::{InteriorField, InteriorElement};
-use borrowck::{LoanPath};
+use borrowck::LoanPath;
use borrowck::LoanPathKind::{LpVar, LpUpvar, LpDowncast, LpExtend};
use borrowck::LoanPathElem::{LpDeref, LpInterior};
-use borrowck::move_data::{InvalidMovePathIndex};
+use borrowck::move_data::InvalidMovePathIndex;
use borrowck::move_data::{MoveData, MovePathIndex};
use rustc::middle::ty;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization as mc;
use rustc::middle::region;
use rustc::middle::ty;
-use rustc::util::ppaux::{Repr};
+use rustc::util::ppaux::Repr;
use syntax::ast;
use syntax::codemap::Span;
use syntax::visit;
assignee_cmt: mc::cmt<'tcx>,
mode: euv::MutateMode)
{
- debug!("mutate(assignment_id={}, assignee_cmt={})",
- assignment_id, assignee_cmt.repr(self.tcx()));
+ let opt_lp = opt_loan_path(&assignee_cmt);
+ debug!("mutate(assignment_id={}, assignee_cmt={}) opt_lp={:?}",
+ assignment_id, assignee_cmt.repr(self.tcx()), opt_lp);
- match opt_loan_path(&assignee_cmt) {
+ match opt_lp {
Some(lp) => {
gather_moves::gather_assignment(self.bccx, &self.move_data,
assignment_id, assignment_span,
req_kind: ty::BorrowKind)
-> Result<(),()> {
- match (cmt.freely_aliasable(bccx.tcx), req_kind) {
- (None, _) => {
+ let aliasability = cmt.freely_aliasable(bccx.tcx);
+ debug!("check_aliasability aliasability={:?} req_kind={:?}",
+ aliasability, req_kind);
+
+ match (aliasability, req_kind) {
+ (mc::Aliasability::NonAliasable, _) => {
/* Uniquely accessible path -- OK for `&` and `&mut` */
Ok(())
}
- (Some(mc::AliasableStatic(safety)), ty::ImmBorrow) => {
+ (mc::Aliasability::FreelyAliasable(mc::AliasableStatic(safety)), ty::ImmBorrow) => {
// Borrow of an immutable static item:
match safety {
mc::InteriorUnsafe => {
}
}
}
- (Some(mc::AliasableStaticMut(..)), _) => {
+ (mc::Aliasability::FreelyAliasable(mc::AliasableStaticMut(..)), _) => {
// Even touching a static mut is considered unsafe. We assume the
// user knows what they're doing in these cases.
Ok(())
}
- (Some(alias_cause), ty::UniqueImmBorrow) |
- (Some(alias_cause), ty::MutBorrow) => {
+ (mc::Aliasability::ImmutableUnique(_), ty::MutBorrow) => {
+ bccx.report_aliasability_violation(
+ borrow_span,
+ BorrowViolation(loan_cause),
+ mc::AliasableReason::UnaliasableImmutable);
+ Err(())
+ }
+ (mc::Aliasability::FreelyAliasable(alias_cause), ty::UniqueImmBorrow) |
+ (mc::Aliasability::FreelyAliasable(alias_cause), ty::MutBorrow) => {
bccx.report_aliasability_violation(
borrow_span,
BorrowViolation(loan_cause),
req_kind: ty::BorrowKind)
-> Result<(),()> {
//! Implements the M-* rules in README.md.
-
+ debug!("check_mutability(cause={:?} cmt={} req_kind={:?}",
+ cause, cmt.repr(bccx.tcx), req_kind);
match req_kind {
ty::UniqueImmBorrow | ty::ImmBorrow => {
match cmt.mutbl {
make_stat(&bccx, bccx.stats.stable_paths));
}
- fn make_stat(bccx: &BorrowckCtxt, stat: uint) -> String {
+ fn make_stat(bccx: &BorrowckCtxt, stat: usize) -> String {
let total = bccx.stats.guaranteed_paths as f64;
let perc = if total == 0.0 { 0.0 } else { stat as f64 * 100.0 / total };
format!("{} ({:.0}%)", stat, perc)
}
struct BorrowStats {
- loaned_paths_same: uint,
- loaned_paths_imm: uint,
- stable_paths: uint,
- guaranteed_paths: uint
+ loaned_paths_same: usize,
+ loaned_paths_imm: usize,
+ stable_paths: usize,
+ guaranteed_paths: usize
}
pub type BckResult<'tcx, T> = Result<T, BckError<'tcx>>;
/// Record of a loan that was issued.
pub struct Loan<'tcx> {
- index: uint,
+ index: usize,
loan_path: Rc<LoanPath<'tcx>>,
kind: ty::BorrowKind,
restricted_paths: Vec<Rc<LoanPath<'tcx>>>,
}
}
- fn depth(&self) -> uint {
+ fn depth(&self) -> usize {
match self.kind {
LpExtend(ref base, _, LpDeref(_)) => base.depth(),
LpExtend(ref base, _, LpInterior(_)) => base.depth() + 1,
&format!("{} in an aliasable location",
prefix));
}
+ mc::AliasableReason::UnaliasableImmutable => {
+ self.tcx.sess.span_err(
+ span,
+ &format!("{} in an immutable container",
+ prefix));
+ }
mc::AliasableClosure(id) => {
self.tcx.sess.span_err(span,
&format!("{} in a captured outer \
impl BitwiseOperator for LoanDataFlowOperator {
#[inline]
- fn join(&self, succ: uint, pred: uint) -> uint {
+ fn join(&self, succ: usize, pred: usize) -> usize {
succ | pred // loans from both preds are in scope
}
}
/// Index into `MoveData.paths`, used like a pointer
#[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
-pub struct MovePathIndex(uint);
+pub struct MovePathIndex(usize);
impl MovePathIndex {
- fn get(&self) -> uint {
+ fn get(&self) -> usize {
let MovePathIndex(v) = *self; v
}
}
/// Index into `MoveData.moves`, used like a pointer
#[derive(Copy, PartialEq)]
-pub struct MoveIndex(uint);
+pub struct MoveIndex(usize);
impl MoveIndex {
- fn get(&self) -> uint {
+ fn get(&self) -> usize {
let MoveIndex(v) = *self; v
}
}
impl BitwiseOperator for MoveDataFlowOperator {
#[inline]
- fn join(&self, succ: uint, pred: uint) -> uint {
+ fn join(&self, succ: usize, pred: usize) -> usize {
succ | pred // moves from both preds are in scope
}
}
impl BitwiseOperator for AssignDataFlowOperator {
#[inline]
- fn join(&self, succ: uint, pred: uint) -> uint {
+ fn join(&self, succ: usize, pred: usize) -> usize {
succ | pred // moves from both preds are in scope
}
}
use borrowck;
use borrowck::{BorrowckCtxt, LoanPath};
use dot;
-use rustc::middle::cfg::{CFGIndex};
+use rustc::middle::cfg::CFGIndex;
use rustc::middle::dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit};
use rustc::middle::dataflow;
use std::rc::Rc;
cfgidx: CFGIndex,
dfcx: &DataFlowContext<'a, 'tcx, O>,
mut to_lp: F) -> String where
- F: FnMut(uint) -> Rc<LoanPath<'tcx>>,
+ F: FnMut(usize) -> Rc<LoanPath<'tcx>>,
{
let mut saw_some = false;
let mut set = "{".to_string();
#![allow(non_camel_case_types)]
-#![feature(core)]
-#![feature(int_uint)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
// for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
// refers to the borrowck-specific graphviz adapter traits.
-extern crate "graphviz" as dot;
+extern crate graphviz as dot;
extern crate rustc;
pub use borrowck::check_crate;
use syntax::ast;
use syntax::ast_map;
use syntax::attr;
-use syntax::attr::{AttrMetaMethods};
+use syntax::attr::AttrMetaMethods;
use syntax::diagnostics;
use syntax::parse;
use syntax::parse::token;
let features =
syntax::feature_gate::check_crate(sess.codemap(),
&sess.parse_sess.span_diagnostic,
- &krate,
- true);
+ &krate);
*sess.features.borrow_mut() = features;
sess.abort_if_errors();
});
let features =
syntax::feature_gate::check_crate(sess.codemap(),
&sess.parse_sess.span_diagnostic,
- &krate,
- false);
+ &krate);
*sess.features.borrow_mut() = features;
sess.abort_if_errors();
});
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(libc)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
extern crate rustc_trans;
extern crate rustc_typeck;
extern crate serialize;
-extern crate "rustc_llvm" as llvm;
+extern crate rustc_llvm as llvm;
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
"https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports";
-pub fn run(args: Vec<String>) -> int {
+pub fn run(args: Vec<String>) -> isize {
monitor(move || run_compiler(&args, &mut RustcDefaultCalls));
0
}
/// errors of the compiler.
#[allow(deprecated)]
pub fn monitor<F:FnOnce()+Send+'static>(f: F) {
- const STACK_SIZE: uint = 8 * 1024 * 1024; // 8MB
+ const STACK_SIZE: usize = 8 * 1024 * 1024; // 8MB
struct Sink(Arc<Mutex<Vec<u8>>>);
impl Write for Sink {
}
}
-fn errors(msgs: &[&str]) -> (Box<Emitter+Send>, uint) {
+fn errors(msgs: &[&str]) -> (Box<Emitter+Send>, usize) {
let v = msgs.iter().map(|m| m.to_string()).collect();
(box ExpectErrorEmitter { messages: v } as Box<Emitter+Send>, msgs.len())
}
fn test_env<F>(source_string: &str,
- (emitter, expected_err_count): (Box<Emitter+Send>, uint),
+ (emitter, expected_err_count): (Box<Emitter+Send>, usize),
body: F) where
F: FnOnce(Env),
{
fn search_mod(this: &Env,
m: &ast::Mod,
- idx: uint,
+ idx: usize,
names: &[String])
-> Option<ast::NodeId> {
assert!(idx < names.len());
fn search(this: &Env,
it: &ast::Item,
- idx: uint,
+ idx: usize,
names: &[String])
-> Option<ast::NodeId> {
if idx == names.len() {
pub fn t_rptr(&self, r: ty::Region) -> Ty<'tcx> {
ty::mk_imm_rptr(self.infcx.tcx,
self.infcx.tcx.mk_region(r),
- self.tcx().types.int)
+ self.tcx().types.isize)
}
pub fn t_rptr_late_bound(&self, id: u32) -> Ty<'tcx> {
let r = self.re_late_bound_with_debruijn(id, ty::DebruijnIndex::new(1));
ty::mk_imm_rptr(self.infcx.tcx,
self.infcx.tcx.mk_region(r),
- self.tcx().types.int)
+ self.tcx().types.isize)
}
pub fn t_rptr_late_bound_with_debruijn(&self,
let r = self.re_late_bound_with_debruijn(id, debruijn);
ty::mk_imm_rptr(self.infcx.tcx,
self.infcx.tcx.mk_region(r),
- self.tcx().types.int)
+ self.tcx().types.isize)
}
pub fn t_rptr_scope(&self, id: ast::NodeId) -> Ty<'tcx> {
let r = ty::ReScope(CodeExtent::from_node_id(id));
ty::mk_imm_rptr(self.infcx.tcx, self.infcx.tcx.mk_region(r),
- self.tcx().types.int)
+ self.tcx().types.isize)
}
pub fn re_free(&self, nid: ast::NodeId, id: u32) -> ty::Region {
let r = self.re_free(nid, id);
ty::mk_imm_rptr(self.infcx.tcx,
self.infcx.tcx.mk_region(r),
- self.tcx().types.int)
+ self.tcx().types.isize)
}
pub fn t_rptr_static(&self) -> Ty<'tcx> {
ty::mk_imm_rptr(self.infcx.tcx,
self.infcx.tcx.mk_region(ty::ReStatic),
- self.tcx().types.int)
+ self.tcx().types.isize)
}
pub fn dummy_type_trace(&self) -> infer::TypeTrace<'tcx> {
fn sub_free_bound_false() {
//! Test that:
//!
- //! fn(&'a int) <: for<'b> fn(&'b int)
+ //! fn(&'a isize) <: for<'b> fn(&'b isize)
//!
//! does NOT hold.
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_free1 = env.t_rptr_free(0, 1);
let t_rptr_bound1 = env.t_rptr_late_bound(1);
- env.check_not_sub(env.t_fn(&[t_rptr_free1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ env.check_not_sub(env.t_fn(&[t_rptr_free1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
})
}
fn sub_bound_free_true() {
//! Test that:
//!
- //! for<'a> fn(&'a int) <: fn(&'b int)
+ //! for<'a> fn(&'a isize) <: fn(&'b isize)
//!
//! DOES hold.
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_free1 = env.t_rptr_free(0, 1);
- env.check_sub(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free1], env.tcx().types.int));
+ env.check_sub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free1], env.tcx().types.isize));
})
}
fn sub_free_bound_false_infer() {
//! Test that:
//!
- //! fn(_#1) <: for<'b> fn(&'b int)
+ //! fn(_#1) <: for<'b> fn(&'b isize)
//!
//! does NOT hold for any instantiation of `_#1`.
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_infer1 = env.infcx.next_ty_var();
let t_rptr_bound1 = env.t_rptr_late_bound(1);
- env.check_not_sub(env.t_fn(&[t_infer1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ env.check_not_sub(env.t_fn(&[t_infer1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
})
}
fn lub_free_bound_infer() {
//! Test result of:
//!
- //! LUB(fn(_#1), for<'b> fn(&'b int))
+ //! LUB(fn(_#1), for<'b> fn(&'b isize))
//!
- //! This should yield `fn(&'_ int)`. We check
- //! that it yields `fn(&'x int)` for some free `'x`,
+ //! This should yield `fn(&'_ isize)`. We check
+ //! that it yields `fn(&'x isize)` for some free `'x`,
//! anyhow.
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_infer1 = env.infcx.next_ty_var();
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_free1 = env.t_rptr_free(0, 1);
- env.check_lub(env.t_fn(&[t_infer1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free1], env.tcx().types.int));
+ env.check_lub(env.t_fn(&[t_infer1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free1], env.tcx().types.isize));
});
}
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_bound2 = env.t_rptr_late_bound(2);
- env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound2], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound2], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
})
}
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_free1 = env.t_rptr_free(0, 1);
- env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free1], env.tcx().types.int));
+ env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free1], env.tcx().types.isize));
})
}
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_static = env.t_rptr_static();
- env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_static], env.tcx().types.int),
- env.t_fn(&[t_rptr_static], env.tcx().types.int));
+ env.check_lub(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_static], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_static], env.tcx().types.isize));
})
}
let t_rptr_free1 = env.t_rptr_free(0, 1);
let t_rptr_free2 = env.t_rptr_free(0, 2);
let t_rptr_static = env.t_rptr_static();
- env.check_lub(env.t_fn(&[t_rptr_free1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free2], env.tcx().types.int),
- env.t_fn(&[t_rptr_static], env.tcx().types.int));
+ env.check_lub(env.t_fn(&[t_rptr_free1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free2], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_static], env.tcx().types.isize));
})
}
let t_rptr_free1 = env.t_rptr_free(0, 1);
let t_rptr_free2 = env.t_rptr_free(0, 2);
let t_rptr_scope = env.t_rptr_scope(0);
- env.check_glb(env.t_fn(&[t_rptr_free1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free2], env.tcx().types.int),
- env.t_fn(&[t_rptr_scope], env.tcx().types.int));
+ env.check_glb(env.t_fn(&[t_rptr_free1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free2], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_scope], env.tcx().types.isize));
})
}
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_bound2 = env.t_rptr_late_bound(2);
- env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound2], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound2], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
})
}
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_free1 = env.t_rptr_free(0, 1);
- env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_free1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_free1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
})
}
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_infer1 = env.infcx.next_ty_var();
- // compute GLB(fn(_) -> int, for<'b> fn(&'b int) -> int),
- // which should yield for<'b> fn(&'b int) -> int
- env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_infer1], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ // compute GLB(fn(_) -> isize, for<'b> fn(&'b isize) -> isize),
+ // which should yield for<'b> fn(&'b isize) -> isize
+ env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_infer1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
// as a side-effect, computing GLB should unify `_` with
- // `&'_ int`
+ // `&'_ isize`
let t_resolve1 = env.infcx.shallow_resolve(t_infer1);
match t_resolve1.sty {
ty::ty_rptr(..) => { }
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let t_rptr_bound1 = env.t_rptr_late_bound(1);
let t_rptr_static = env.t_rptr_static();
- env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.int),
- env.t_fn(&[t_rptr_static], env.tcx().types.int),
- env.t_fn(&[t_rptr_bound1], env.tcx().types.int));
+ env.check_glb(env.t_fn(&[t_rptr_bound1], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_static], env.tcx().types.isize),
+ env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
})
}
let substs = subst::Substs::new_type(vec![t_rptr_bound1], vec![]);
let t_substituted = t_source.subst(env.infcx.tcx, &substs);
- // t_expected = fn(&'a int)
+ // t_expected = fn(&'a isize)
let t_expected = {
let t_ptr_bound2 = env.t_rptr_late_bound_with_debruijn(1, ty::DebruijnIndex::new(2));
env.t_fn(&[t_ptr_bound2], env.t_nil())
let substs = subst::Substs::new_type(vec![t_rptr_bound1], vec![]);
let t_substituted = t_source.subst(env.infcx.tcx, &substs);
- // t_expected = (&'a int, fn(&'a int))
+ // t_expected = (&'a isize, fn(&'a isize))
//
// but not that the Debruijn index is different in the different cases.
let t_expected = {
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let re_bound1 = env.re_late_bound_with_debruijn(1, ty::DebruijnIndex::new(1));
- // type t_source<'a> = fn(&'a int)
+ // type t_source<'a> = fn(&'a isize)
let t_source = {
let re_early = env.re_early_bound(subst::TypeSpace, 0, "'a");
env.t_fn(&[env.t_rptr(re_early)], env.t_nil())
let substs = subst::Substs::new_type(vec![], vec![re_bound1]);
let t_substituted = t_source.subst(env.infcx.tcx, &substs);
- // t_expected = fn(&'a int)
+ // t_expected = fn(&'a isize)
//
// but not that the Debruijn index is different in the different cases.
let t_expected = {
fn walk_ty() {
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let tcx = env.infcx.tcx;
- let int_ty = tcx.types.int;
- let uint_ty = tcx.types.uint;
+ let int_ty = tcx.types.isize;
+ let uint_ty = tcx.types.usize;
let tup1_ty = ty::mk_tup(tcx, vec!(int_ty, uint_ty, int_ty, uint_ty));
let tup2_ty = ty::mk_tup(tcx, vec!(tup1_ty, tup1_ty, uint_ty));
let uniq_ty = ty::mk_uniq(tcx, tup2_ty);
fn walk_ty_skip_subtree() {
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
let tcx = env.infcx.tcx;
- let int_ty = tcx.types.int;
- let uint_ty = tcx.types.uint;
+ let int_ty = tcx.types.isize;
+ let uint_ty = tcx.types.usize;
let tup1_ty = ty::mk_tup(tcx, vec!(int_ty, uint_ty, int_ty, uint_ty));
let tup2_ty = ty::mk_tup(tcx, vec!(tup1_ty, tup1_ty, uint_ty));
let uniq_ty = ty::mk_uniq(tcx, tup2_ty);
(uint_ty, false),
(int_ty, false),
(uint_ty, false),
- (tup1_ty, true), // skip the int/uint/int/uint
+ (tup1_ty, true), // skip the isize/usize/isize/usize
(uint_ty, false));
expected.reverse();
use middle::{def, pat_util, stability};
use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
use middle::cfg;
-use util::ppaux::{ty_to_string};
+use util::ppaux::ty_to_string;
use util::nodemap::{FnvHashMap, NodeSet};
use lint::{Level, Context, LintPass, LintArray, Lint};
-use std::collections::BitSet;
+use std::collections::{HashSet, BitSet};
use std::collections::hash_map::Entry::{Occupied, Vacant};
-use std::num::SignedInt;
use std::{cmp, slice};
use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
if let ast::LitInt(shift, _) = lit.node { shift >= bits }
else { false }
} else {
- match eval_const_expr_partial(cx.tcx, &**r, Some(cx.tcx.types.uint)) {
+ match eval_const_expr_partial(cx.tcx, &**r, Some(cx.tcx.types.usize)) {
Ok(const_int(shift)) => { shift as u64 >= bits },
Ok(const_uint(shift)) => { shift >= bits },
_ => { false }
match lit.node {
ast::LitInt(v, ast::SignedIntLit(_, ast::Plus)) |
ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => {
- let int_type = if let ast::TyIs(_) = t {
+ let int_type = if let ast::TyIs = t {
cx.sess().target.int_type
} else {
t
};
},
ty::ty_uint(t) => {
- let uint_type = if let ast::TyUs(_) = t {
+ let uint_type = if let ast::TyUs = t {
cx.sess().target.uint_type
} else {
t
// warnings are consistent between 32- and 64-bit platforms
fn int_ty_range(int_ty: ast::IntTy) -> (i64, i64) {
match int_ty {
- ast::TyIs(_) => (i64::MIN, i64::MAX),
+ ast::TyIs => (i64::MIN, i64::MAX),
ast::TyI8 => (i8::MIN as i64, i8::MAX as i64),
ast::TyI16 => (i16::MIN as i64, i16::MAX as i64),
ast::TyI32 => (i32::MIN as i64, i32::MAX as i64),
fn uint_ty_range(uint_ty: ast::UintTy) -> (u64, u64) {
match uint_ty {
- ast::TyUs(_) => (u64::MIN, u64::MAX),
+ ast::TyUs => (u64::MIN, u64::MAX),
ast::TyU8 => (u8::MIN as u64, u8::MAX as u64),
ast::TyU16 => (u16::MIN as u64, u16::MAX as u64),
ast::TyU32 => (u32::MIN as u64, u32::MAX as u64),
fn int_ty_bits(int_ty: ast::IntTy, target_int_ty: ast::IntTy) -> u64 {
match int_ty {
- ast::TyIs(_) => int_ty_bits(target_int_ty, target_int_ty),
+ ast::TyIs => int_ty_bits(target_int_ty, target_int_ty),
ast::TyI8 => i8::BITS as u64,
ast::TyI16 => i16::BITS as u64,
ast::TyI32 => i32::BITS as u64,
fn uint_ty_bits(uint_ty: ast::UintTy, target_uint_ty: ast::UintTy) -> u64 {
match uint_ty {
- ast::TyUs(_) => uint_ty_bits(target_uint_ty, target_uint_ty),
+ ast::TyUs => uint_ty_bits(target_uint_ty, target_uint_ty),
ast::TyU8 => u8::BITS as u64,
ast::TyU16 => u16::BITS as u64,
ast::TyU32 => u32::BITS as u64,
impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
fn check_def(&mut self, sp: Span, id: ast::NodeId) {
match self.cx.tcx.def_map.borrow().get(&id).unwrap().full_def() {
- def::DefPrimTy(ast::TyInt(ast::TyIs(_))) => {
+ def::DefPrimTy(ast::TyInt(ast::TyIs)) => {
self.cx.span_lint(IMPROPER_CTYPES, sp,
"found rust type `isize` in foreign module, while \
libc::c_int or libc::c_long should be used");
}
- def::DefPrimTy(ast::TyUint(ast::TyUs(_))) => {
+ def::DefPrimTy(ast::TyUint(ast::TyUs)) => {
self.cx.span_lint(IMPROPER_CTYPES, sp,
"found rust type `usize` in foreign module, while \
libc::c_uint or libc::c_ulong should be used");
/// Stack of whether #[doc(hidden)] is set
/// at each level which has lint attributes.
doc_hidden_stack: Vec<bool>,
+
+ /// Private traits or trait items that leaked through. Don't check their methods.
+ private_traits: HashSet<ast::NodeId>,
}
impl MissingDoc {
struct_def_stack: vec!(),
in_variant: false,
doc_hidden_stack: vec!(false),
+ private_traits: HashSet::new(),
}
}
ast::ItemMod(..) => "a module",
ast::ItemEnum(..) => "an enum",
ast::ItemStruct(..) => "a struct",
- ast::ItemTrait(..) => "a trait",
+ ast::ItemTrait(_, _, _, ref items) => {
+ // Issue #11592, traits are always considered exported, even when private.
+ if it.vis == ast::Visibility::Inherited {
+ self.private_traits.insert(it.id);
+ for itm in items {
+ self.private_traits.insert(itm.id);
+ }
+ return
+ }
+ "a trait"
+ },
ast::ItemTy(..) => "a type alias",
+ ast::ItemImpl(_, _, _, Some(ref trait_ref), _, ref impl_items) => {
+ // If the trait is private, add the impl items to private_traits so they don't get
+ // reported for missing docs.
+ let real_trait = ty::trait_ref_to_def_id(cx.tcx, trait_ref);
+ match cx.tcx.map.find(real_trait.node) {
+ Some(ast_map::NodeItem(item)) => if item.vis == ast::Visibility::Inherited {
+ for itm in impl_items {
+ self.private_traits.insert(itm.id);
+ }
+ },
+ _ => { }
+ }
+ return
+ },
_ => return
};
+
self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs, it.span, desc);
}
fn check_trait_item(&mut self, cx: &Context, trait_item: &ast::TraitItem) {
+ if self.private_traits.contains(&trait_item.id) { return }
+
let desc = match trait_item.node {
ast::MethodTraitItem(..) => "a trait method",
ast::TypeTraitItem(..) => "an associated type"
};
+
self.check_missing_docs_attrs(cx, Some(trait_item.id),
&trait_item.attrs,
trait_item.span, desc);
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
if ptr.is_null() {
None
} else {
- Some(slice::from_raw_parts(ptr as *const u8, size as uint))
+ Some(slice::from_raw_parts(ptr as *const u8, size as usize))
}
}
}
#![allow(non_snake_case)]
#![allow(dead_code)]
#![allow(trivial_casts)]
-#![allow(trivial_numeric_casts)]
#![crate_name = "rustc_llvm"]
#![unstable(feature = "rustc_private")]
#![feature(box_syntax)]
#![feature(collections)]
-#![feature(int_uint)]
#![feature(libc)]
#![feature(link_args)]
#![feature(staged_api)]
pub const True: Bool = 1 as Bool;
pub const False: Bool = 0 as Bool;
-// Consts for the LLVM CallConv type, pre-cast to uint.
+// Consts for the LLVM CallConv type, pre-cast to usize.
#[derive(Copy, PartialEq)]
pub enum CallConv {
}
pub struct AttrBuilder {
- attrs: Vec<(u
int, Box<AttrHelper+'static>)>
+ attrs: Vec<(u
size, Box<AttrHelper+'static>)>
}
impl AttrBuilder {
}
}
- pub fn arg<'a, T: AttrHelper + 'static>(&'a mut self, idx: uint, a: T) -> &'a mut AttrBuilder {
+ pub fn arg<'a, T: AttrHelper + 'static>(&'a mut self, idx: usize, a: T) -> &'a mut AttrBuilder {
self.attrs.push((idx, box a as Box<AttrHelper+'static>));
self
}
pub fn ret<'a, T: AttrHelper + 'static>(&'a mut self, a: T) -> &'a mut AttrBuilder {
- self.attrs.push((ReturnIndex as u
int, box a as Box<AttrHelper+'static>));
+ self.attrs.push((ReturnIndex as u
size, box a as Box<AttrHelper+'static>));
self
}
-> ValueRef;
pub fn LLVMConstFCmp(Pred: c_ushort, V1: ValueRef, V2: ValueRef)
-> ValueRef;
- /* only for int/vector */
+ /* only for isize/vector */
pub fn LLVMGetUndef(Ty: TypeRef) -> ValueRef;
pub fn LLVMIsConstant(Val: ValueRef) -> Bool;
pub fn LLVMIsNull(Val: ValueRef) -> Bool;
pub fn new(llmb: MemoryBufferRef) -> Option<ObjectFile> {
unsafe {
let llof = LLVMCreateObjectFile(llmb);
- if llof as int == 0 {
+ if llof as isize == 0 {
// LLVMCreateObjectFile took ownership of llmb
return None
}
pub unsafe extern "C" fn rust_llvm_string_write_impl(sr: RustStringRef,
ptr: *const c_char,
size: size_t) {
- let slice = slice::from_raw_parts(ptr as *const u8, size as uint);
+ let slice = slice::from_raw_parts(ptr as *const u8, size as usize);
let sr: RustStringRepr = mem::transmute(sr);
(*sr).borrow_mut().push_all(slice);
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(int_uint)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
#![feature(staged_api)]
use rustc::middle::ty::{MethodTypeParam, MethodStatic};
use rustc::middle::ty::{MethodCall, MethodMap, MethodOrigin, MethodParam};
use rustc::middle::ty::{MethodStaticClosure, MethodObject};
-use rustc::middle::ty::{MethodTraitObject};
+use rustc::middle::ty::MethodTraitObject;
use rustc::middle::ty::{self, Ty};
use rustc::util::nodemap::{NodeMap, NodeSet};
}
enum FieldName {
- UnnamedField(uint), // index
+ UnnamedField(usize), // index
// (Name, not Ident, because struct fields are not macro-hygienic)
NamedField(ast::Name),
}
use syntax::ast::TupleVariantKind;
use syntax::ast::UnnamedField;
use syntax::ast::{Variant, ViewPathGlob, ViewPathList, ViewPathSimple};
-use syntax::ast::{Visibility};
+use syntax::ast::Visibility;
use syntax::ast;
use syntax::ast_util::local_def;
use syntax::attr::AttrMetaMethods;
#![feature(alloc)]
#![feature(collections)]
-#![feature(core)]
-#![feature(int_uint)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
#![feature(staged_api)]
use syntax::ast::{TyF64, TyFloat, TyIs, TyI8, TyI16, TyI32, TyI64, TyInt};
use syntax::ast::{TyPath, TyPtr};
use syntax::ast::{TyRptr, TyStr, TyUs, TyU8, TyU16, TyU32, TyU64, TyUint};
-use syntax::ast::{TypeImplItem};
+use syntax::ast::TypeImplItem;
use syntax::ast;
use syntax::ast_map;
use syntax::ast_util::{local_def, walk_pat};
enum ModulePrefixResult {
NoPrefixFound,
- PrefixFound(Rc<Module>, uint)
+ PrefixFound(Rc<Module>, usize)
}
#[derive(Copy, PartialEq)]
import_resolutions: RefCell<HashMap<Name, ImportResolution>>,
// The number of unresolved globs that this module exports.
- glob_count: Cell<uint>,
+ glob_count: Cell<usize>,
// The index of the import we're resolving.
- resolved_import_count: Cell<uint>,
+ resolved_import_count: Cell<usize>,
// Whether this module is populated. If not populated, any attempt to
// access the children must be preceded with a
table.intern("char", TyChar);
table.intern("f32", TyFloat(TyF32));
table.intern("f64", TyFloat(TyF64));
- table.intern("int", TyInt(TyIs(true)));
- table.intern("isize", TyInt(TyIs(false)));
+ table.intern("isize", TyInt(TyIs));
table.intern("i8", TyInt(TyI8));
table.intern("i16", TyInt(TyI16));
table.intern("i32", TyInt(TyI32));
table.intern("i64", TyInt(TyI64));
table.intern("str", TyStr);
- table.intern("uint", TyUint(TyUs(true)));
- table.intern("usize", TyUint(TyUs(false)));
+ table.intern("usize", TyUint(TyUs));
table.intern("u8", TyUint(TyU8));
table.intern("u16", TyUint(TyU16));
table.intern("u32", TyUint(TyU32));
structs: FnvHashMap<DefId, Vec<Name>>,
// The number of imports that are currently unresolved.
- unresolved_imports: uint,
+ unresolved_imports: usize,
// The module that represents the current item scope.
current_module: Rc<Module>,
fn resolve_module_path_from_root(&mut self,
module_: Rc<Module>,
module_path: &[Name],
- index: uint,
+ index: usize,
span: Span,
name_search_type: NameSearchType,
lp: LastPrivate)
NoSuggestion
}
- fn find_best_match_for_name(&mut self, name: &str, max_distance: uint)
+ fn find_best_match_for_name(&mut self, name: &str, max_distance: usize)
-> Option<String> {
let this = &mut *self;
let mut maybes: Vec<token::InternedString> = Vec::new();
- let mut values: Vec<uint> = Vec::new();
+ let mut values: Vec<usize> = Vec::new();
for rib in this.value_ribs.iter().rev() {
for (&k, _) in &rib.bindings {
// Note that this is usually either 0 or 1 - shadowing is forbidden the only
// way outstanding_references is > 1 in a legal program is if the name is
// used in both namespaces.
- pub outstanding_references: uint,
+ pub outstanding_references: usize,
/// The value that this `use` directive names, if there is one.
pub value_target: Option<Target>,
pub const RLIB_BYTECODE_OBJECT_VERSION: u32 = 1;
// The offset in bytes the bytecode object format version number can be found at
-pub const RLIB_BYTECODE_OBJECT_VERSION_OFFSET: uint = 11;
+pub const RLIB_BYTECODE_OBJECT_VERSION_OFFSET: usize = 11;
// The offset in bytes the size of the compressed bytecode can be found at in
// format version 1
-pub const RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET: uint =
+pub const RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET: usize =
RLIB_BYTECODE_OBJECT_VERSION_OFFSET + 4;
// The offset in bytes the compressed LLVM bytecode can be found at in format
// version 1
-pub const RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET: uint =
+pub const RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET: usize =
RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET + 8;
}
if let Input::File(ref path) = *input {
if let Some(s) = path.file_stem().and_then(|s| s.to_str()) {
- return validate(s.to_string(), None);
+ if s.starts_with("-") {
+ let msg = format!("crate names cannot start with a `-`, but \
+ `{}` has a leading hyphen", s);
+ if let Some(sess) = sess {
+ sess.err(&msg);
+ }
+ } else {
+ return validate(s.replace("-", "_"), None);
+ }
}
}
- "rust-out".to_string()
+ "rust_out".to_string()
}
pub fn build_link_meta(sess: &Session, krate: &ast::Crate,
"abcdefghijklmnopqrstuvwxyz\
ABCDEFGHIJKLMNOPQRSTUVWXYZ\
0123456789";
- let id = id as uint;
+ let id = id as usize;
let extra1 = id % EXTRA_CHARS.len();
let id = id / EXTRA_CHARS.len();
let extra2 = id % EXTRA_CHARS.len();
}
config::CrateTypeExecutable => {
let suffix = &sess.target.target.options.exe_suffix;
- out_filename.with_file_name(&format!("{}{}", libname, suffix))
+ if suffix.len() == 0 {
+ out_filename.to_path_buf()
+ } else {
+ out_filename.with_extension(&suffix[1..])
+ }
}
}
}
RLIB_BYTECODE_OBJECT_MAGIC.len() + // magic id
mem::size_of_val(&RLIB_BYTECODE_OBJECT_VERSION) + // version
mem::size_of_val(&bc_data_deflated_size) + // data size field
- bc_data_deflated_size as uint; // actual data
+ bc_data_deflated_size as usize; // actual data
// If the number of bytes written to the object so far is odd, add a
// padding byte to make it even. This works around a crash bug in LLDB
// We may not pass all crates through to the linker. Some crates may
// appear statically in an existing dylib, meaning we'll pick up all the
// symbols from the dylib.
- let kind = match data[cnum as uint - 1] {
+ let kind = match data[cnum as usize - 1] {
Some(t) => t,
None => continue
};
use std::ffi::CString;
use std::mem;
+#[allow(deprecated)]
use std::num::Int;
pub fn run(sess: &session::Session, llmod: ModuleRef,
let data_size = extract_compressed_bytecode_size_v1(bc_encoded);
let compressed_data = &bc_encoded[
link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET..
- (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint)];
+ (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as usize)];
match flate::inflate_bytes(compressed_data) {
Ok(inflated) => inflated,
return read_from_le_bytes::<u64>(bc, link::RLIB_BYTECODE_OBJECT_V1_DATASIZE_OFFSET);
}
-fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: uint) -> T {
+#[allow(deprecated)]
+fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: usize) -> T {
let byte_data = &bytes[position_in_bytes..position_in_bytes + mem::size_of::<T>()];
let data = unsafe {
*(byte_data.as_ptr() as *const T)
fn run_work_multithreaded(sess: &Session,
work_items: Vec<WorkItem>,
- num_workers: uint) {
+ num_workers: usize) {
// Run some workers to process the work items.
let work_items_arc = Arc::new(Mutex::new(work_items));
let mut diag_emitter = SharedEmitter::new();
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(libc)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(path_relative_from)]
#![allow(trivial_casts)]
-#![allow(trivial_numeric_casts)]
extern crate arena;
extern crate flate;
extern crate rustc;
extern crate rustc_back;
extern crate serialize;
-extern crate "rustc_llvm" as llvm;
+extern crate rustc_llvm as llvm;
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
// However full span is the entire enum/fn/struct block, so we only want
// the first few to match the number of generics we're looking for.
let param_sub_spans = self.span.spans_for_ty_params(full_span,
- (generics.ty_params.len() as int));
+ (generics.ty_params.len() as isize));
for (param, param_ss) in generics.ty_params.iter().zip(param_sub_spans.iter()) {
// Append $id to name to make sure each one is unique
let name = format!("{}::{}${}",
#[derive(Clone)]
pub struct SpanUtils<'a> {
pub sess: &'a Session,
- pub err_count: Cell<int>,
+ pub err_count: Cell<isize>,
}
impl<'a> SpanUtils<'a> {
// example with Foo<Bar<T,V>, Bar<T,V>>
// Nesting = 0: all idents outside of brackets: ~[Foo]
// Nesting = 1: idents within one level of brackets: ~[Bar, Bar]
- pub fn spans_with_brackets(&self, span: Span, nesting: int, limit: int) -> Vec<Span> {
+ pub fn spans_with_brackets(&self, span: Span, nesting: isize, limit: isize) -> Vec<Span> {
let mut result: Vec<Span> = vec!();
let mut toks = self.retokenise_span(span);
}
return result
}
- if (result.len() as int) == limit {
+ if (result.len() as isize) == limit {
return result;
}
bracket_count += match ts.tok {
// Return an owned vector of the subspans of the param identifier
// tokens found in span.
- pub fn spans_for_ty_params(&self, span: Span, number: int) -> Vec<Span> {
+ pub fn spans_for_ty_params(&self, span: Span, number: isize) -> Vec<Span> {
if generated_code(span) {
return vec!();
}
//! constituent pattern. N here is usually the number of arms but may be
//! greater, if some arms have multiple alternatives. For example, here:
//!
-//! enum Foo { A, B(int), C(uint, uint) }
+//! enum Foo { A, B(int), C(usize, usize) }
//! match foo {
//! A => ...,
//! B(x) => ...,
ConstantValue(ConstantExpr<'a>, DebugLoc),
ConstantRange(ConstantExpr<'a>, ConstantExpr<'a>, DebugLoc),
Variant(ty::Disr, Rc<adt::Repr<'tcx>>, ast::DefId, DebugLoc),
- SliceLengthEqual(uint, DebugLoc),
- SliceLengthGreaterOrEqual(/* prefix length */ uint,
- /* suffix length */ uint,
+ SliceLengthEqual(usize, DebugLoc),
+ SliceLengthGreaterOrEqual(/* prefix length */ usize,
+ /* suffix length */ usize,
DebugLoc),
}
}
}
-fn has_nested_bindings(m: &[Match], col: uint) -> bool {
+fn has_nested_bindings(m: &[Match], col: usize) -> bool {
for br in m {
match br.pats[col].node {
ast::PatIdent(_, _, Some(_)) => return true,
fn expand_nested_bindings<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
m: &[Match<'a, 'p, 'blk, 'tcx>],
- col: uint,
+ col: usize,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
debug!("expand_nested_bindings(bcx={}, m={}, col={}, val={})",
fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
dm: &DefMap,
m: &[Match<'a, 'p, 'blk, 'tcx>],
- col: uint,
+ col: usize,
val: ValueRef,
mut e: F)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> where
fn enter_default<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
dm: &DefMap,
m: &[Match<'a, 'p, 'blk, 'tcx>],
- col: uint,
+ col: usize,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
debug!("enter_default(bcx={}, m={}, col={}, val={})",
dm: &DefMap,
m: &[Match<'a, 'p, 'blk, 'tcx>],
opt: &Opt,
- col: uint,
- variant_size: uint,
+ col: usize,
+ variant_size: usize,
val: ValueRef)
-> Vec<Match<'a, 'p, 'blk, 'tcx>> {
debug!("enter_opt(bcx={}, m={}, opt={:?}, col={}, val={})",
// on a set of enum variants or a literal.
fn get_branches<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
m: &[Match<'a, 'p, 'blk, 'tcx>],
- col: uint)
+ col: usize)
-> Vec<Opt<'p, 'tcx>> {
let tcx = bcx.tcx();
fn bind_subslice_pat(bcx: Block,
pat_id: ast::NodeId,
val: ValueRef,
- offset_left: uint,
- offset_right: uint) -> ValueRef {
+ offset_left: usize,
+ offset_right: usize) -> ValueRef {
let _icx = push_ctxt("match::bind_subslice_pat");
let vec_ty = node_id_type(bcx, pat_id);
let unit_ty = ty::sequence_element_type(bcx.tcx(), ty::type_content(vec_ty));
fn extract_vec_elems<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
left_ty: Ty<'tcx>,
- before: uint,
- after: uint,
+ before: usize,
+ after: usize,
val: ValueRef)
-> ExtractedBlock<'blk, 'tcx> {
let _icx = push_ctxt("match::extract_vec_elems");
)
}
-fn any_uniq_pat(m: &[Match], col: uint) -> bool {
+fn any_uniq_pat(m: &[Match], col: usize) -> bool {
any_pat!(m, col, ast::PatBox(_))
}
-fn any_region_pat(m: &[Match], col: uint) -> bool {
+fn any_region_pat(m: &[Match], col: usize) -> bool {
any_pat!(m, col, ast::PatRegion(..))
}
-fn any_irrefutable_adt_pat(tcx: &ty::ctxt, m: &[Match], col: uint) -> bool {
+fn any_irrefutable_adt_pat(tcx: &ty::ctxt, m: &[Match], col: usize) -> bool {
m.iter().any(|br| {
let pat = br.pats[col];
match pat.node {
}
}
-fn pick_column_to_specialize(def_map: &DefMap, m: &[Match]) -> Option<uint> {
- fn pat_score(def_map: &DefMap, pat: &ast::Pat) -> uint {
+fn pick_column_to_specialize(def_map: &DefMap, m: &[Match]) -> Option<usize> {
+ fn pat_score(def_map: &DefMap, pat: &ast::Pat) -> usize {
match pat.node {
ast::PatIdent(_, _, Some(ref inner)) => pat_score(def_map, &**inner),
_ if pat_is_refutable(def_map, pat) => 1,
}
}
- let column_score = |m: &[Match], col: uint| -> uint {
+ let column_score = |m: &[Match], col: usize| -> usize {
let total_score = m.iter()
.map(|row| row.pats[col])
.map(|pat| pat_score(def_map, pat))
}
};
- let column_contains_any_nonwild_patterns = |&col: &uint| -> bool {
+ let column_contains_any_nonwild_patterns = |&col: &usize| -> bool {
m.iter().any(|row| match row.pats[col].node {
ast::PatWild(_) => false,
_ => true
m: &[Match<'a, 'p, 'blk, 'tcx>],
vals: &[ValueRef],
chk: &FailureHandler,
- col: uint,
+ col: usize,
val: ValueRef,
has_genuine_default: bool) {
let fcx = bcx.fcx;
let t = if kind == Compare {
left_ty
} else {
- tcx.types.uint // vector length
+ tcx.types.usize // vector length
};
let Result { bcx: after_cx, val: matches } = {
match opt.trans(bcx) {
let scope = cleanup::var_scope(tcx, p_id);
bcx = mk_binding_alloca(
bcx, p_id, &path1.node, scope, (),
- |(), bcx, llval, ty| { zero_mem(bcx, llval, ty); bcx });
+ |(), bcx, llval, ty| { drop_done_fill_mem(bcx, llval, ty); bcx });
});
bcx
}
pub use self::Repr::*;
+#[allow(deprecated)]
use std::num::Int;
use std::rc::Rc;
/// Structs with destructors need a dynamic destroyedness flag to
/// avoid running the destructor too many times; this is included
/// in the `Struct` if present.
- Univariant(Struct<'tcx>, bool),
+ /// (The flag if nonzero, represents the initialization value to use;
+ /// if zero, then use no flag at all.)
+ Univariant(Struct<'tcx>, u8),
/// General-case enums: for each case there is a struct, and they
/// all start with a field for the discriminant.
///
/// Types with destructors need a dynamic destroyedness flag to
/// avoid running the destructor too many times; the last argument
/// indicates whether such a flag is present.
- General(IntType, Vec<Struct<'tcx>>, bool),
+ /// (The flag, if nonzero, represents the initialization value to use;
+ /// if zero, then use no flag at all.)
+ General(IntType, Vec<Struct<'tcx>>, u8),
/// Two cases distinguished by a nullable pointer: the case with discriminant
/// `nndiscr` must have single field which is known to be nonnull due to its type.
/// The other case is known to be zero sized. Hence we represent the enum
repr
}
+macro_rules! repeat_u8_as_u32 {
+ ($name:expr) => { (($name as u32) << 24 |
+ ($name as u32) << 16 |
+ ($name as u32) << 8 |
+ ($name as u32)) }
+}
+macro_rules! repeat_u8_as_u64 {
+ ($name:expr) => { ((repeat_u8_as_u32!($name) as u64) << 32 |
+ (repeat_u8_as_u32!($name) as u64)) }
+}
+
+pub const DTOR_NEEDED: u8 = 0xd4;
+pub const DTOR_NEEDED_U32: u32 = repeat_u8_as_u32!(DTOR_NEEDED);
+pub const DTOR_NEEDED_U64: u64 = repeat_u8_as_u64!(DTOR_NEEDED);
+#[allow(dead_code)]
+pub fn dtor_needed_usize(ccx: &CrateContext) -> usize {
+ match &ccx.tcx().sess.target.target.target_pointer_width[..] {
+ "32" => DTOR_NEEDED_U32 as usize,
+ "64" => DTOR_NEEDED_U64 as usize,
+ tws => panic!("Unsupported target word size for int: {}", tws),
+ }
+}
+
+pub const DTOR_DONE: u8 = 0x1d;
+pub const DTOR_DONE_U32: u32 = repeat_u8_as_u32!(DTOR_DONE);
+pub const DTOR_DONE_U64: u64 = repeat_u8_as_u64!(DTOR_DONE);
+#[allow(dead_code)]
+pub fn dtor_done_usize(ccx: &CrateContext) -> usize {
+ match &ccx.tcx().sess.target.target.target_pointer_width[..] {
+ "32" => DTOR_DONE_U32 as usize,
+ "64" => DTOR_DONE_U64 as usize,
+ tws => panic!("Unsupported target word size for int: {}", tws),
+ }
+}
+
+fn dtor_to_init_u8(dtor: bool) -> u8 {
+ if dtor { DTOR_NEEDED } else { 0 }
+}
+
+pub trait GetDtorType<'tcx> { fn dtor_type(&self) -> Ty<'tcx>; }
+impl<'tcx> GetDtorType<'tcx> for ty::ctxt<'tcx> {
+ fn dtor_type(&self) -> Ty<'tcx> { self.types.u8 }
+}
+
+fn dtor_active(flag: u8) -> bool {
+ flag != 0
+}
+
fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
t: Ty<'tcx>) -> Repr<'tcx> {
match t.sty {
ty::ty_tup(ref elems) => {
- Univariant(mk_struct(cx, &elems[..], false, t), false)
+ Univariant(mk_struct(cx, &elems[..], false, t), 0)
}
ty::ty_struct(def_id, substs) => {
let fields = ty::lookup_struct_fields(cx.tcx(), def_id);
}).collect::<Vec<_>>();
let packed = ty::lookup_packed(cx.tcx(), def_id);
let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag();
- if dtor { ftys.push(cx.tcx().types.bool); }
+ if dtor { ftys.push(cx.tcx().dtor_type()); }
- Univariant(mk_struct(cx, &ftys[..], packed, t), dtor)
+ Univariant(mk_struct(cx, &ftys[..], packed, t), dtor_to_init_u8(dtor))
}
ty::ty_closure(def_id, substs) => {
let typer = NormalizingClosureTyper::new(cx.tcx());
let upvars = typer.closure_upvars(def_id, substs).unwrap();
let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
- Univariant(mk_struct(cx, &upvar_types[..], false, t), false)
+ Univariant(mk_struct(cx, &upvar_types[..], false, t), 0)
}
ty::ty_enum(def_id, substs) => {
let cases = get_cases(cx.tcx(), def_id, substs);
// Uninhabitable; represent as unit
// (Typechecking will reject discriminant-sizing attrs.)
assert_eq!(hint, attr::ReprAny);
- let ftys = if dtor { vec!(cx.tcx().types.bool) } else { vec!() };
+ let ftys = if dtor { vec!(cx.tcx().dtor_type()) } else { vec!() };
return Univariant(mk_struct(cx, &ftys[..], false, t),
- dtor);
+ dtor_to_init_u8(dtor));
}
if !dtor && cases.iter().all(|c| c.tys.len() == 0) {
// (Typechecking will reject discriminant-sizing attrs.)
assert_eq!(hint, attr::ReprAny);
let mut ftys = cases[0].tys.clone();
- if dtor { ftys.push(cx.tcx().types.bool); }
+ if dtor { ftys.push(cx.tcx().dtor_type()); }
return Univariant(mk_struct(cx, &ftys[..], false, t),
- dtor);
+ dtor_to_init_u8(dtor));
}
if !dtor && cases.len() == 2 && hint == attr::ReprAny {
let fields : Vec<_> = cases.iter().map(|c| {
let mut ftys = vec!(ty_of_inttype(cx.tcx(), min_ity));
ftys.push_all(&c.tys);
- if dtor { ftys.push(cx.tcx().types.bool); }
+ if dtor { ftys.push(cx.tcx().dtor_type()); }
mk_struct(cx, &ftys, false, t)
}).collect();
let fields : Vec<_> = cases.iter().map(|c| {
let mut ftys = vec!(ty_of_inttype(cx.tcx(), ity));
ftys.push_all(&c.tys);
- if dtor { ftys.push(cx.tcx().types.bool); }
+ if dtor { ftys.push(cx.tcx().dtor_type()); }
mk_struct(cx, &ftys[..], false, t)
}).collect();
ensure_enum_fits_in_address_space(cx, &fields[..], t);
- General(ity, fields, dtor)
+ General(ity, fields, dtor_to_init_u8(dtor))
}
_ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}",
ty_to_string(cx.tcx(), t)))
}
/// This represents the (GEP) indices to follow to get to the discriminant field
-pub type DiscrField = Vec<uint>;
+pub type DiscrField = Vec<usize>;
fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>,
ty: Ty<'tcx>,
assert_eq!(val_ty(ptr), llty.ptr_to());
let bits = machine::llbitsize_of_real(bcx.ccx(), llty);
assert!(bits <= 64);
- let bits = bits as uint;
+ let bits = bits as usize;
let mask = (-1u64 >> (64 - bits)) as Disr;
// For a (max) discr of -1, max will be `-1 as usize`, which overflows.
// However, that is fine here (it would still represent the full range),
val)
}
General(ity, ref cases, dtor) => {
- if dtor {
+ if dtor_active(dtor) {
let ptr = trans_field_ptr(bcx, r, val, discr,
- cases[discr as uint].fields.len() - 2);
- Store(bcx, C_u8(bcx.ccx(), 1), ptr);
+ cases[discr as usize].fields.len() - 2);
+ Store(bcx, C_u8(bcx.ccx(), DTOR_NEEDED as usize), ptr);
}
Store(bcx, C_integral(ll_inttype(bcx.ccx(), ity), discr as u64, true),
GEPi(bcx, val, &[0, 0]))
}
Univariant(ref st, dtor) => {
assert_eq!(discr, 0);
- if dtor {
- Store(bcx, C_u8(bcx.ccx(), 1),
+ if dtor_active(dtor) {
+ Store(bcx, C_u8(bcx.ccx(), DTOR_NEEDED as usize),
GEPi(bcx, val, &[0, st.fields.len() - 1]));
}
}
/// The number of fields in a given case; for use when obtaining this
/// information from the type or definition is less convenient.
-pub fn num_args(r: &Repr, discr: Disr) -> uint {
+pub fn num_args(r: &Repr, discr: Disr) -> usize {
match *r {
CEnum(..) => 0,
Univariant(ref st, dtor) => {
assert_eq!(discr, 0);
- st.fields.len() - (if dtor { 1 } else { 0 })
+ st.fields.len() - (if dtor_active(dtor) { 1 } else { 0 })
}
General(_, ref cases, dtor) => {
- cases[discr as uint].fields.len() - 1 - (if dtor { 1 } else { 0 })
+ cases[discr as usize].fields.len() - 1 - (if dtor_active(dtor) { 1 } else { 0 })
}
RawNullablePointer { nndiscr, ref nullfields, .. } => {
if discr == nndiscr { 1 } else { nullfields.len() }
/// Access a field, at a point when the value's case is known.
pub fn trans_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>,
- val: ValueRef, discr: Disr, ix: uint) -> ValueRef {
+ val: ValueRef, discr: Disr, ix: usize) -> ValueRef {
// Note: if this ever needs to generate conditionals (e.g., if we
// decide to do some kind of cdr-coding-like non-unique repr
// someday), it will need to return a possibly-new bcx as well.
struct_field_ptr(bcx, st, val, ix, false)
}
General(_, ref cases, _) => {
- struct_field_ptr(bcx, &cases[discr as uint], val, ix + 1, true)
+ struct_field_ptr(bcx, &cases[discr as usize], val, ix + 1, true)
}
RawNullablePointer { nndiscr, ref nullfields, .. } |
StructWrappedNullablePointer { nndiscr, ref nullfields, .. } if discr != nndiscr => {
}
pub fn struct_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, st: &Struct<'tcx>, val: ValueRef,
- ix: uint, needs_cast: bool) -> ValueRef {
+ ix: usize, needs_cast: bool) -> ValueRef {
let val = if needs_cast {
let ccx = bcx.ccx();
let fields = st.fields.iter().map(|&ty| type_of::type_of(ccx, ty)).collect::<Vec<_>>();
-> datum::DatumBlock<'blk, 'tcx, datum::Expr>
{
let tcx = bcx.tcx();
- let ptr_ty = ty::mk_imm_ptr(bcx.tcx(), tcx.types.bool);
+ let ptr_ty = ty::mk_imm_ptr(bcx.tcx(), tcx.dtor_type());
match *r {
- Univariant(ref st, true) => {
+ Univariant(ref st, dtor) if dtor_active(dtor) => {
let flag_ptr = GEPi(bcx, val, &[0, st.fields.len() - 1]);
datum::immediate_rvalue_bcx(bcx, flag_ptr, ptr_ty).to_expr_datumblock()
}
- General(_, _, true) => {
+ General(_, _, dtor) if dtor_active(dtor) => {
let fcx = bcx.fcx;
let custom_cleanup_scope = fcx.push_custom_cleanup_scope();
let scratch = unpack_datum!(bcx, datum::lvalue_scratch_datum(
- bcx, tcx.types.bool, "drop_flag",
+ bcx, tcx.dtor_type(), "drop_flag",
cleanup::CustomScope(custom_cleanup_scope), (), |_, bcx, _| bcx
));
bcx = fold_variants(bcx, r, val, |variant_cx, st, value| {
C_integral(ll_inttype(ccx, ity), discr as u64, true)
}
General(ity, ref cases, _) => {
- let case = &cases[discr as uint];
+ let case = &cases[discr as usize];
let (max_sz, _) = union_size_and_align(&cases[..]);
let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true);
let mut f = vec![lldiscr];
/// (Not to be confused with `common::const_get_elt`, which operates on
/// raw LLVM-level structs and arrays.)
pub fn const_get_field(ccx: &CrateContext, r: &Repr, val: ValueRef,
- _discr: Disr, ix: uint) -> ValueRef {
+ _discr: Disr, ix: usize) -> ValueRef {
match *r {
CEnum(..) => ccx.sess().bug("element access in C-like enum const"),
Univariant(..) => const_struct_field(ccx, val, ix),
}
/// Extract field of struct-like const, skipping our alignment padding.
-fn const_struct_field(ccx: &CrateContext, val: ValueRef, ix: uint) -> ValueRef {
+fn const_struct_field(ccx: &CrateContext, val: ValueRef, ix: usize) -> ValueRef {
// Get the ix-th non-undef element of the struct.
let mut real_ix = 0; // actual position in the struct
let mut ix = ix; // logical index relative to real_ix
use super::CrateTranslation;
use super::ModuleTranslation;
-use back::link::{mangle_exported_name};
+use back::link::mangle_exported_name;
use back::{link, abi};
use lint;
use llvm::{AttrHelper, BasicBlockRef, Linkage, ValueRef, Vector, get_param};
pub struct StatRecorder<'a, 'tcx: 'a> {
ccx: &'a CrateContext<'a, 'tcx>,
name: Option<String>,
- istart: uint,
+ istart: usize,
}
impl<'a, 'tcx> StatRecorder<'a, 'tcx> {
_ => bcx.sess().bug("compare_scalar_types: must be a comparison operator")
}
}
- ty::ty_bool | ty::ty_uint(_) | ty::ty_char => {
+ ty::ty_bare_fn(..) | ty::ty_bool | ty::ty_uint(_) | ty::ty_char => {
ICmp(bcx, bin_op_to_icmp_predicate(bcx.ccx(), op, false), lhs, rhs, debug_loc)
}
ty::ty_ptr(mt) if common::type_is_sized(bcx.tcx(), mt.ty) => {
substs, &mut f);
}
(_match::Switch, Some(lldiscrim_a)) => {
- cx = f(cx, lldiscrim_a, cx.tcx().types.int);
+ cx = f(cx, lldiscrim_a, cx.tcx().types.isize);
let unr_cx = fcx.new_temp_block("enum-iter-unr");
Unreachable(unr_cx);
let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb,
ty::ty_int(t) => {
let llty = Type::int_from_ty(cx.ccx(), t);
let min = match t {
- ast::TyIs(_) if llty == Type::i32(cx.ccx()) => i32::MIN as u64,
- ast::TyIs(_) => i64::MIN as u64,
+ ast::TyIs if llty == Type::i32(cx.ccx()) => i32::MIN as u64,
+ ast::TyIs => i64::MIN as u64,
ast::TyI8 => i8::MIN as u64,
ast::TyI16 => i16::MIN as u64,
ast::TyI32 => i32::MIN as u64,
}
}
-pub fn zero_mem<'blk, 'tcx>(cx: Block<'blk, 'tcx>, llptr: ValueRef, t: Ty<'tcx>) {
+pub fn drop_done_fill_mem<'blk, 'tcx>(cx: Block<'blk, 'tcx>, llptr: ValueRef, t: Ty<'tcx>) {
if cx.unreachable.get() { return; }
- let _icx = push_ctxt("zero_mem");
+ let _icx = push_ctxt("drop_done_fill_mem");
let bcx = cx;
- memzero(&B(bcx), llptr, t);
+ memfill(&B(bcx), llptr, t, adt::DTOR_DONE);
}
-// Always use this function instead of storing a zero constant to the memory
-// in question. If you store a zero constant, LLVM will drown in vreg
+pub fn init_zero_mem<'blk, 'tcx>(cx: Block<'blk, 'tcx>, llptr: ValueRef, t: Ty<'tcx>) {
+ if cx.unreachable.get() { return; }
+ let _icx = push_ctxt("init_zero_mem");
+ let bcx = cx;
+ memfill(&B(bcx), llptr, t, 0);
+}
+
+// Always use this function instead of storing a constant byte to the memory
+// in question. e.g. if you store a zero constant, LLVM will drown in vreg
// allocation for large data structures, and the generated code will be
// awful. (A telltale sign of this is large quantities of
// `mov [byte ptr foo],0` in the generated code.)
-fn memzero<'a, 'tcx>(b: &Builder<'a, 'tcx>, llptr: ValueRef, ty: Ty<'tcx>) {
- let _icx = push_ctxt("memzero");
+fn memfill<'a, 'tcx>(b: &Builder<'a, 'tcx>, llptr: ValueRef, ty: Ty<'tcx>, byte: u8) {
+ let _icx = push_ctxt("memfill");
let ccx = b.ccx;
let llty = type_of::type_of(ccx, ty);
let llintrinsicfn = ccx.get_intrinsic(&intrinsic_key);
let llptr = b.pointercast(llptr, Type::i8(ccx).ptr_to());
- let llzeroval = C_u8(ccx, 0);
+ let llzeroval = C_u8(ccx, byte as usize);
let size = machine::llsize_of(ccx, llty);
let align = C_i32(ccx, type_of::align_of(ccx, ty) as i32);
let volatile = C_bool(ccx, false);
tcx.sess.opts.debug_assertions
};
+ let check_dropflag = if let Some(v) = tcx.sess.opts.debugging_opts.force_dropflag_checks {
+ v
+ } else {
+ tcx.sess.opts.debug_assertions
+ };
+
// Before we touch LLVM, make sure that multithreading is enabled.
unsafe {
use std::sync::{Once, ONCE_INIT};
Sha256::new(),
link_meta.clone(),
reachable,
- check_overflow);
+ check_overflow,
+ check_dropflag);
{
let ccx = shared_ccx.get_ccx(0);
// except according to those terms.
use llvm;
-use llvm::{BasicBlockRef};
+use llvm::BasicBlockRef;
use trans::value::{Users, Value};
use std::iter::{Filter, Map};
B(cx).cond_br(if_, then, else_);
}
-pub fn Switch(cx: Block, v: ValueRef, else_: BasicBlockRef, num_cases: uint)
+pub fn Switch(cx: Block, v: ValueRef, else_: BasicBlockRef, num_cases: usize)
-> ValueRef {
if cx.unreachable.get() { return _Undef(v); }
check_not_terminated(cx);
pub fn IndirectBr(cx: Block,
addr: ValueRef,
- num_dests: uint,
+ num_dests: usize,
debug_loc: DebugLoc) {
if cx.unreachable.get() {
return;
// Simple wrapper around GEP that takes an array of ints and wraps them
// in C_i32()
#[inline]
-pub fn GEPi(cx: Block, base: ValueRef, ixs: &[uint]) -> ValueRef {
+pub fn GEPi(cx: Block, base: ValueRef, ixs: &[usize]) -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::nil(cx.ccx()).ptr_to().to_ref());
}
}
-pub fn StructGEP(cx: Block, pointer: ValueRef, idx: uint) -> ValueRef {
+pub fn StructGEP(cx: Block, pointer: ValueRef, idx: usize) -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::nil(cx.ccx()).ptr_to().to_ref());
}
}
-pub fn VectorSplat(cx: Block, num_elts: uint, elt_val: ValueRef) -> ValueRef {
+pub fn VectorSplat(cx: Block, num_elts: usize, elt_val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::nil(cx.ccx()).to_ref());
}
}
-pub fn ExtractValue(cx: Block, agg_val: ValueRef, index: uint) -> ValueRef {
+pub fn ExtractValue(cx: Block, agg_val: ValueRef, index: usize) -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::nil(cx.ccx()).to_ref());
}
}
-pub fn InsertValue(cx: Block, agg_val: ValueRef, elt_val: ValueRef, index: uint) -> ValueRef {
+pub fn InsertValue(cx: Block, agg_val: ValueRef, elt_val: ValueRef, index: usize) -> ValueRef {
unsafe {
if cx.unreachable.get() {
return llvm::LLVMGetUndef(Type::nil(cx.ccx()).to_ref());
}
pub fn LandingPad(cx: Block, ty: Type, pers_fn: ValueRef,
- num_clauses: uint) -> ValueRef {
+ num_clauses: usize) -> ValueRef {
check_not_terminated(cx);
assert!(!cx.unreachable.get());
B(cx).landing_pad(ty, pers_fn, num_clauses)
}
}
- pub fn switch(&self, v: ValueRef, else_llbb: BasicBlockRef, num_cases: uint) -> ValueRef {
+ pub fn switch(&self, v: ValueRef, else_llbb: BasicBlockRef, num_cases: usize) -> ValueRef {
unsafe {
llvm::LLVMBuildSwitch(self.llbuilder, v, else_llbb, num_cases as c_uint)
}
}
- pub fn indirect_br(&self, addr: ValueRef, num_dests: uint) {
+ pub fn indirect_br(&self, addr: ValueRef, num_dests: usize) {
self.count_insn("indirectbr");
unsafe {
llvm::LLVMBuildIndirectBr(self.llbuilder, addr, num_dests as c_uint);
// Simple wrapper around GEP that takes an array of ints and wraps them
// in C_i32()
#[inline]
- pub fn gepi(&self, base: ValueRef, ixs: &[uint]) -> ValueRef {
+ pub fn gepi(&self, base: ValueRef, ixs: &[usize]) -> ValueRef {
// Small vector optimization. This should catch 100% of the cases that
// we care about.
if ixs.len() < 16 {
}
}
- pub fn struct_gep(&self, ptr: ValueRef, idx: uint) -> ValueRef {
+ pub fn struct_gep(&self, ptr: ValueRef, idx: usize) -> ValueRef {
self.count_insn("structgep");
unsafe {
llvm::LLVMBuildStructGEP(self.llbuilder, ptr, idx as c_uint, noname())
}
}
- pub fn vector_splat(&self, num_elts: uint, elt: ValueRef) -> ValueRef {
+ pub fn vector_splat(&self, num_elts: usize, elt: ValueRef) -> ValueRef {
unsafe {
let elt_ty = val_ty(elt);
let undef = llvm::LLVMGetUndef(Type::vector(&elt_ty, num_elts as u64).to_ref());
}
}
- pub fn extract_value(&self, agg_val: ValueRef, idx: uint) -> ValueRef {
+ pub fn extract_value(&self, agg_val: ValueRef, idx: usize) -> ValueRef {
self.count_insn("extractvalue");
unsafe {
llvm::LLVMBuildExtractValue(self.llbuilder, agg_val, idx as c_uint, noname())
}
pub fn insert_value(&self, agg_val: ValueRef, elt: ValueRef,
- idx: uint) -> ValueRef {
+ idx: usize) -> ValueRef {
self.count_insn("insertvalue");
unsafe {
llvm::LLVMBuildInsertValue(self.llbuilder, agg_val, elt, idx as c_uint,
let m: ModuleRef = llvm::LLVMGetGlobalParent(fn_);
let p = "llvm.trap\0".as_ptr();
let t: ValueRef = llvm::LLVMGetNamedFunction(m, p as *const _);
- assert!((t as int != 0));
+ assert!((t as isize != 0));
let args: &[ValueRef] = &[];
self.count_insn("trap");
llvm::LLVMBuildCall(
}
}
- pub fn landing_pad(&self, ty: Type, pers_fn: ValueRef, num_clauses: uint) -> ValueRef {
+ pub fn landing_pad(&self, ty: Type, pers_fn: ValueRef, num_clauses: usize) -> ValueRef {
self.count_insn("landingpad");
unsafe {
llvm::LLVMBuildLandingPad(
use std::cmp;
-fn align_up_to(off: uint, a: uint) -> uint {
+fn align_up_to(off: usize, a: usize) -> usize {
return (off + a - 1) / a * a;
}
-fn align(off: uint, ty: Type) -> uint {
+fn align(off: usize, ty: Type) -> usize {
let a = ty_align(ty);
return align_up_to(off, a);
}
-fn ty_align(ty: Type) -> uint {
+fn ty_align(ty: Type) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 8,
Float => 4,
Double => 8,
}
}
-fn ty_size(ty: Type) -> uint {
+fn ty_size(ty: Type) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 8,
Float => 4,
Double => 8,
Ios
}
-type TyAlignFn = fn(ty: Type) -> uint;
+type TyAlignFn = fn(ty: Type) -> usize;
-fn align_up_to(off: uint, a: uint) -> uint {
+fn align_up_to(off: usize, a: usize) -> usize {
return (off + a - 1) / a * a;
}
-fn align(off: uint, ty: Type, align_fn: TyAlignFn) -> uint {
+fn align(off: usize, ty: Type, align_fn: TyAlignFn) -> usize {
let a = align_fn(ty);
return align_up_to(off, a);
}
-fn general_ty_align(ty: Type) -> uint {
+fn general_ty_align(ty: Type) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 4,
Float => 4,
Double => 8,
// ARMv6
// https://developer.apple.com/library/ios/documentation/Xcode/Conceptual
// /iPhoneOSABIReference/Articles/ARMv6FunctionCallingConventions.html
-fn ios_ty_align(ty: Type) -> uint {
+fn ios_ty_align(ty: Type) -> usize {
match ty.kind() {
- Integer => cmp::min(4, ((ty.int_width() as uint) + 7) / 8),
+ Integer => cmp::min(4, ((ty.int_width() as usize) + 7) / 8),
Pointer => 4,
Float => 4,
Double => 4,
}
}
-fn ty_size(ty: Type, align_fn: TyAlignFn) -> uint {
+fn ty_size(ty: Type, align_fn: TyAlignFn) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 4,
Float => 4,
Double => 8,
use trans::context::CrateContext;
use trans::type_::Type;
-fn align_up_to(off: uint, a: uint) -> uint {
+fn align_up_to(off: usize, a: usize) -> usize {
return (off + a - 1) / a * a;
}
-fn align(off: uint, ty: Type) -> uint {
+fn align(off: usize, ty: Type) -> usize {
let a = ty_align(ty);
return align_up_to(off, a);
}
-fn ty_align(ty: Type) -> uint {
+fn ty_align(ty: Type) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 4,
Float => 4,
Double => 8,
}
}
-fn ty_size(ty: Type) -> uint {
+fn ty_size(ty: Type) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 4,
Float => 4,
Double => 8,
}
}
-fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
+fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut usize) -> ArgType {
let orig_offset = *offset;
let size = ty_size(ty) * 8;
let mut align = ty_align(ty);
};
}
-fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
+fn padding_ty(ccx: &CrateContext, align: usize, offset: usize) -> Option<Type> {
if ((align - 1 ) & offset) > 0 {
Some(Type::i32(ccx))
} else {
}
}
-fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
+fn coerce_to_int(ccx: &CrateContext, size: usize) -> Vec<Type> {
let int_ty = Type::i32(ccx);
let mut args = Vec::new();
use std::cmp;
-fn align_up_to(off: uint, a: uint) -> uint {
+fn align_up_to(off: usize, a: usize) -> usize {
return (off + a - 1) / a * a;
}
-fn align(off: uint, ty: Type) -> uint {
+fn align(off: usize, ty: Type) -> usize {
let a = ty_align(ty);
return align_up_to(off, a);
}
-fn ty_align(ty: Type) -> uint {
+fn ty_align(ty: Type) -> usize {
match ty.kind() {
Integer => {
unsafe {
- ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
+ ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as usize) + 7) / 8
}
}
Pointer => 4,
}
}
-fn ty_size(ty: Type) -> uint {
+fn ty_size(ty: Type) -> usize {
match ty.kind() {
Integer => {
unsafe {
- ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
+ ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as usize) + 7) / 8
}
}
Pointer => 4,
}
}
-fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
+fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut usize) -> ArgType {
let orig_offset = *offset;
let size = ty_size(ty) * 8;
let mut align = ty_align(ty);
};
}
-fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
+fn padding_ty(ccx: &CrateContext, align: usize, offset: usize) -> Option<Type> {
if ((align - 1 ) & offset) > 0 {
Some(Type::i32(ccx))
} else {
}
}
-fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
+fn coerce_to_int(ccx: &CrateContext, size: usize) -> Vec<Type> {
let int_ty = Type::i32(ccx);
let mut args = Vec::new();
}
fn classify_ty(ty: Type) -> Vec<RegClass> {
- fn align(off: uint, ty: Type) -> uint {
+ fn align(off: usize, ty: Type) -> usize {
let a = ty_align(ty);
return (off + a - 1) / a * a;
}
- fn ty_align(ty: Type) -> uint {
+ fn ty_align(ty: Type) -> usize {
match ty.kind() {
- Integer => ((ty.int_width() as uint) + 7) / 8,
+ Integer => ((ty.int_width() as usize) + 7) / 8,
Pointer => 8,
Float => 4,
Double => 8,
}
}
- fn ty_size(ty: Type) -> uint {
+ fn ty_size(ty: Type) -> usize {
match ty.kind() {
- Integer => (ty.int_width() as uint + 7) / 8,
+ Integer => (ty.int_width() as usize + 7) / 8,
Pointer => 8,
Float => 4,
Double => 8,
}
fn unify(cls: &mut [RegClass],
- i: uint,
+ i: usize,
newv: RegClass) {
if cls[i] == newv { return }
fn classify_struct(tys: &[Type],
cls: &mut [RegClass],
- i: uint,
- off: uint,
+ i: usize,
+ off: usize,
packed: bool) {
let mut field_off = off;
for ty in tys {
}
fn classify(ty: Type,
- cls: &mut [RegClass], ix: uint,
- off: uint) {
+ cls: &mut [RegClass], ix: usize,
+ off: usize) {
let t_align = ty_align(ty);
let t_size = ty_size(ty);
}
fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type {
- fn llvec_len(cls: &[RegClass]) -> uint {
+ fn llvec_len(cls: &[RegClass]) -> usize {
let mut len = 1;
for c in cls {
if *c != SSEUp {
use arena::TypedArena;
use back::link;
use session;
-use llvm::{ValueRef};
+use llvm::ValueRef;
use llvm::get_param;
use llvm;
use metadata::csearch;
#[derive(Copy, Debug)]
pub struct CustomScopeIndex {
- index: uint
+ index: usize
}
-pub const EXIT_BREAK: uint = 0;
-pub const EXIT_LOOP: uint = 1;
-pub const EXIT_MAX: uint = 2;
+pub const EXIT_BREAK: usize = 0;
+pub const EXIT_LOOP: usize = 1;
+pub const EXIT_MAX: usize = 2;
pub enum CleanupScopeKind<'blk, 'tcx: 'blk> {
CustomScopeKind,
pub enum EarlyExitLabel {
UnwindExit,
ReturnExit,
- LoopExit(ast::NodeId, uint)
+ LoopExit(ast::NodeId, usize)
}
#[derive(Copy)]
/// break/continue (depending on `exit`) out of the loop with id `cleanup_scope`
fn normal_exit_block(&'blk self,
cleanup_scope: ast::NodeId,
- exit: uint) -> BasicBlockRef {
+ exit: usize) -> BasicBlockRef {
self.trans_cleanups_to_exit_scope(LoopExit(cleanup_scope, exit))
}
None
}
- fn top_nonempty_cleanup_scope(&self) -> Option<uint> {
+ fn top_nonempty_cleanup_scope(&self) -> Option<usize> {
self.scopes.borrow().iter().rev().position(|s| !s.cleanups.is_empty())
}
bcx
}
- fn scopes_len(&self) -> uint {
+ fn scopes_len(&self) -> usize {
self.scopes.borrow().len()
}
/// If this is a loop scope with id `id`, return the early exit block `exit`, else `None`
fn early_exit_block(&self,
id: ast::NodeId,
- exit: uint) -> Option<BasicBlockRef> {
+ exit: usize) -> Option<BasicBlockRef> {
match *self {
LoopScopeKind(i, ref exits) if id == i => Some(exits[exit].llbb),
_ => None,
glue::drop_ty(bcx, self.val, self.ty, debug_loc)
};
if self.zero {
- base::zero_mem(bcx, self.val, self.ty);
+ base::drop_done_fill_mem(bcx, self.val, self.ty);
}
bcx
}
fn top_loop_scope(&self) -> ast::NodeId;
fn normal_exit_block(&'blk self,
cleanup_scope: ast::NodeId,
- exit: uint) -> BasicBlockRef;
+ exit: usize) -> BasicBlockRef;
fn return_exit_block(&'blk self) -> BasicBlockRef;
fn schedule_lifetime_end(&self,
cleanup_scope: ScopeId,
trait CleanupHelperMethods<'blk, 'tcx> {
fn top_ast_scope(&self) -> Option<ast::NodeId>;
- fn top_nonempty_cleanup_scope(&self) -> Option<uint>;
+ fn top_nonempty_cleanup_scope(&self) -> Option<usize>;
fn is_valid_to_pop_custom_scope(&self, custom_scope: CustomScopeIndex) -> bool;
fn is_valid_custom_scope(&self, custom_scope: CustomScopeIndex) -> bool;
fn trans_scope_cleanups(&self,
label: EarlyExitLabel)
-> BasicBlockRef;
fn get_or_create_landing_pad(&'blk self) -> BasicBlockRef;
- fn scopes_len(&self) -> uint;
+ fn scopes_len(&self) -> usize;
fn push_scope(&self, scope: CleanupScope<'blk, 'tcx>);
fn pop_scope(&self) -> CleanupScope<'blk, 'tcx>;
fn top_scope<R, F>(&self, f: F) -> R where F: FnOnce(&CleanupScope<'blk, 'tcx>) -> R;
use trans::monomorphize::{self, MonoId};
use trans::type_of::*;
use middle::ty::{self, ClosureTyper};
-use middle::subst::{Substs};
+use middle::subst::Substs;
use session::config::FullDebugInfo;
use util::ppaux::Repr;
}
impl<'a, 'tcx> FunctionContext<'a, 'tcx> {
- pub fn arg_pos(&self, arg: uint) -> uint {
+ pub fn arg_pos(&self, arg: usize) -> usize {
let arg = self.env_arg_pos() + arg;
if self.llenv.is_some() {
arg + 1
}
}
- pub fn env_arg_pos(&self) -> uint {
+ pub fn env_arg_pos(&self) -> usize {
if self.caller_expects_out_pointer {
1
} else {
// are host-architecture-dependent
impl AsI64 for i64 { fn as_i64(self) -> i64 { self as i64 }}
impl AsI64 for i32 { fn as_i64(self) -> i64 { self as i64 }}
-impl AsI64 for int { fn as_i64(self) -> i64 { self as i64 }}
+impl AsI64 for isize { fn as_i64(self) -> i64 { self as i64 }}
impl AsU64 for u64 { fn as_u64(self) -> u64 { self as u64 }}
impl AsU64 for u32 { fn as_u64(self) -> u64 { self as u64 }}
-impl AsU64 for uint { fn as_u64(self) -> u64 { self as u64 }}
+impl AsU64 for usize { fn as_u64(self) -> u64 { self as u64 }}
-pub fn C_u8(ccx: &CrateContext, i: uint) -> ValueRef {
+pub fn C_u8(ccx: &CrateContext, i: usize) -> ValueRef {
C_integral(Type::i8(ccx), i as u64, false)
}
vtable
}
-pub fn predicates_hold<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
- predicates: Vec<ty::Predicate<'tcx>>)
- -> bool
+/// Normalizes the predicates and checks whether they hold. If this
+/// returns false, then either normalize encountered an error or one
+/// of the predicates did not hold. Used when creating vtables to
+/// check for unsatisfiable methods.
+pub fn normalize_and_test_predicates<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+ predicates: Vec<ty::Predicate<'tcx>>)
+ -> bool
{
- debug!("predicates_hold(predicates={})",
+ debug!("normalize_and_test_predicates(predicates={})",
predicates.repr(ccx.tcx()));
- let infcx = infer::new_infer_ctxt(ccx.tcx());
+ let tcx = ccx.tcx();
+ let infcx = infer::new_infer_ctxt(tcx);
+ let typer = NormalizingClosureTyper::new(tcx);
+ let mut selcx = traits::SelectionContext::new(&infcx, &typer);
let mut fulfill_cx = traits::FulfillmentContext::new();
+ let cause = traits::ObligationCause::dummy();
+ let traits::Normalized { value: predicates, obligations } =
+ traits::normalize(&mut selcx, cause.clone(), &predicates);
+ for obligation in obligations {
+ fulfill_cx.register_predicate_obligation(&infcx, obligation);
+ }
for predicate in predicates {
- let obligation = traits::Obligation::new(traits::ObligationCause::dummy(), predicate);
+ let obligation = traits::Obligation::new(cause.clone(), predicate);
fulfill_cx.register_predicate_obligation(&infcx, obligation);
}
drain_fulfillment_cx(&infcx, &mut fulfill_cx, &()).is_ok()
}
_ => cx.sess().span_bug(lit.span,
&format!("integer literal has type {} (expected int \
- or uint)",
+ or usize)",
ty_to_string(cx.tcx(), lit_int_ty)))
}
}
fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
e: &ast::Expr,
ety: Ty<'tcx>,
- param_substs: &'tcx Substs<'tcx>) -> ValueRef {
+ param_substs: &'tcx Substs<'tcx>)
+ -> ValueRef
+{
+ debug!("const_expr_unadjusted(e={}, ety={}, param_substs={})",
+ e.repr(cx.tcx()),
+ ety.repr(cx.tcx()),
+ param_substs.repr(cx.tcx()));
+
let map_list = |exprs: &[P<ast::Expr>]| {
exprs.iter().map(|e| const_expr(cx, &**e, param_substs).0)
.fold(Vec::new(), |mut l, val| { l.push(val); l })
/* Neither type is bottom, and we expect them to be unified
* already, so the following is safe. */
let (te1, ty) = const_expr(cx, &**e1, param_substs);
+ debug!("const_expr_unadjusted: te1={}, ty={}",
+ cx.tn().val_to_string(te1),
+ ty.repr(cx.tcx()));
let is_simd = ty::type_is_simd(cx.tcx(), ty);
let intype = if is_simd {
ty::simd_type(cx.tcx(), ty)
let unit_ty = ty::sequence_element_type(cx.tcx(), ety);
let llunitty = type_of::type_of(cx, unit_ty);
let n = match const_eval::eval_const_expr_partial(cx.tcx(), &**count, None) {
- Ok(const_eval::const_int(i)) => i as uint,
- Ok(const_eval::const_uint(i)) => i as uint,
+ Ok(const_eval::const_int(i)) => i as usize,
+ Ok(const_eval::const_uint(i)) => i as usize,
_ => cx.sess().span_bug(count.span, "count must be integral const expression.")
};
let unit_val = const_expr(cx, &**elem, param_substs).0;
use llvm;
use llvm::{ContextRef, ModuleRef, ValueRef, BuilderRef};
-use llvm::{TargetData};
+use llvm::TargetData;
use llvm::mk_target_data;
use metadata::common::LinkMeta;
use middle::def::ExportMap;
use syntax::parse::token::InternedString;
pub struct Stats {
- pub n_glues_created: Cell<uint>,
- pub n_null_glues: Cell<uint>,
- pub n_real_glues: Cell<uint>,
- pub n_fns: Cell<uint>,
- pub n_monos: Cell<uint>,
- pub n_inlines: Cell<uint>,
- pub n_closures: Cell<uint>,
- pub n_llvm_insns: Cell<uint>,
- pub llvm_insns: RefCell<FnvHashMap<String, uint>>,
+ pub n_glues_created: Cell<usize>,
+ pub n_null_glues: Cell<usize>,
+ pub n_real_glues: Cell<usize>,
+ pub n_fns: Cell<usize>,
+ pub n_monos: Cell<usize>,
+ pub n_inlines: Cell<usize>,
+ pub n_closures: Cell<usize>,
+ pub n_llvm_insns: Cell<usize>,
+ pub llvm_insns: RefCell<FnvHashMap<String, usize>>,
// (ident, llvm-instructions)
- pub fn_stats: RefCell<Vec<(String, uint)> >,
+ pub fn_stats: RefCell<Vec<(String, usize)> >,
}
/// The shared portion of a `CrateContext`. There is one `SharedCrateContext`
tcx: ty::ctxt<'tcx>,
stats: Stats,
check_overflow: bool,
+ check_drop_flag_for_sanity: bool,
available_monomorphizations: RefCell<FnvHashSet<String>>,
available_drop_glues: RefCell<FnvHashMap<Ty<'tcx>, String>>,
external_srcs: RefCell<NodeMap<ast::DefId>>,
/// Cache instances of monomorphized functions
monomorphized: RefCell<FnvHashMap<MonoId<'tcx>, ValueRef>>,
- monomorphizing: RefCell<DefIdMap<uint>>,
+ monomorphizing: RefCell<DefIdMap<usize>>,
/// Cache generated vtables
vtables: RefCell<FnvHashMap<ty::PolyTraitRef<'tcx>, ValueRef>>,
/// Cache of constant strings,
/// Number of LLVM instructions translated into this `LocalCrateContext`.
/// This is used to perform some basic load-balancing to keep all LLVM
/// contexts around the same size.
- n_llvm_insns: Cell<uint>,
+ n_llvm_insns: Cell<usize>,
trait_cache: RefCell<FnvHashMap<ty::PolyTraitRef<'tcx>,
traits::Vtable<'tcx, ()>>>,
local: &'a LocalCrateContext<'tcx>,
/// The index of `local` in `shared.local_ccxs`. This is used in
/// `maybe_iter(true)` to identify the original `LocalCrateContext`.
- index: uint,
+ index: usize,
}
pub struct CrateContextIterator<'a, 'tcx: 'a> {
shared: &'a SharedCrateContext<'tcx>,
- index: uint,
+ index: usize,
}
impl<'a, 'tcx> Iterator for CrateContextIterator<'a,'tcx> {
/// The iterator produced by `CrateContext::maybe_iter`.
pub struct CrateContextMaybeIterator<'a, 'tcx: 'a> {
shared: &'a SharedCrateContext<'tcx>,
- index: uint,
+ index: usize,
single: bool,
- origin: uint,
+ origin: usize,
}
impl<'a, 'tcx> Iterator for CrateContextMaybeIterator<'a, 'tcx> {
impl<'tcx> SharedCrateContext<'tcx> {
pub fn new(crate_name: &str,
- local_count: uint,
+ local_count: usize,
tcx: ty::ctxt<'tcx>,
export_map: ExportMap,
symbol_hasher: Sha256,
link_meta: LinkMeta,
reachable: NodeSet,
- check_overflow: bool)
+ check_overflow: bool,
+ check_drop_flag_for_sanity: bool)
-> SharedCrateContext<'tcx> {
let (metadata_llcx, metadata_llmod) = unsafe {
create_context_and_module(&tcx.sess, "metadata")
fn_stats: RefCell::new(Vec::new()),
},
check_overflow: check_overflow,
+ check_drop_flag_for_sanity: check_drop_flag_for_sanity,
available_monomorphizations: RefCell::new(FnvHashSet()),
available_drop_glues: RefCell::new(FnvHashMap()),
};
}
}
- pub fn get_ccx<'a>(&'a self, index: uint) -> CrateContext<'a, 'tcx> {
+ pub fn get_ccx<'a>(&'a self, index: usize) -> CrateContext<'a, 'tcx> {
CrateContext {
shared: self,
local: &self.local_ccxs[index],
CrateContext {
shared: shared,
local: self,
- index: -1 as uint,
+ index: -1 as usize,
}
}
}
&self.local.monomorphized
}
- pub fn monomorphizing<'a>(&'a self) -> &'a RefCell<DefIdMap<uint>> {
+ pub fn monomorphizing<'a>(&'a self) -> &'a RefCell<DefIdMap<usize>> {
&self.local.monomorphizing
}
pub fn check_overflow(&self) -> bool {
self.shared.check_overflow
}
+
+ pub fn check_drop_flag_for_sanity(&self) -> bool {
+ // This controls whether we emit a conditional llvm.debugtrap
+ // guarded on whether the dropflag is one of its (two) valid
+ // values.
+ self.shared.check_drop_flag_for_sanity
+ }
}
fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef> {
pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr,
opt_label: Option<Ident>,
- exit: uint)
+ exit: usize)
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("trans_break_cont");
let fcx = bcx.fcx;
use trans::tvec;
use trans::type_of;
use middle::ty::{self, Ty};
-use util::ppaux::{ty_to_string};
+use util::ppaux::ty_to_string;
use std::fmt;
use syntax::ast;
-> Block<'blk, 'tcx> {
let _icx = push_ctxt("<Lvalue as KindOps>::post_store");
if bcx.fcx.type_needs_drop(ty) {
- // cancel cleanup of affine values by zeroing out
- let () = zero_mem(bcx, val, ty);
+ // cancel cleanup of affine values by drop-filling the memory
+ let () = drop_done_fill_mem(bcx, val, ty);
bcx
} else {
bcx
struct FunctionDebugContextData {
scope_map: RefCell<NodeMap<DIScope>>,
fn_metadata: DISubprogram,
- argument_counter: Cell<uint>,
+ argument_counter: Cell<usize>,
source_locations_enabled: Cell<bool>,
source_location_override: Cell<bool>,
}
}
enum VariableKind {
- ArgumentVariable(uint /*index*/),
+ ArgumentVariable(usize /*index*/),
LocalVariable,
CapturedVariable,
}
pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
node_id: ast::NodeId,
env_pointer: ValueRef,
- env_index: uint,
+ env_index: usize,
captured_by_ref: bool,
span: Span) {
if bcx.unreachable.get() ||
ty::ty_bool => ("bool".to_string(), DW_ATE_boolean),
ty::ty_char => ("char".to_string(), DW_ATE_unsigned_char),
ty::ty_int(int_ty) => match int_ty {
- ast::TyIs(_) => ("isize".to_string(), DW_ATE_signed),
+ ast::TyIs => ("isize".to_string(), DW_ATE_signed),
ast::TyI8 => ("i8".to_string(), DW_ATE_signed),
ast::TyI16 => ("i16".to_string(), DW_ATE_signed),
ast::TyI32 => ("i32".to_string(), DW_ATE_signed),
ast::TyI64 => ("i64".to_string(), DW_ATE_signed)
},
ty::ty_uint(uint_ty) => match uint_ty {
- ast::TyUs(_) => ("usize".to_string(), DW_ATE_unsigned),
+ ast::TyUs => ("usize".to_string(), DW_ATE_unsigned),
ast::TyU8 => ("u8".to_string(), DW_ATE_unsigned),
ast::TyU16 => ("u16".to_string(), DW_ATE_unsigned),
ast::TyU32 => ("u32".to_string(), DW_ATE_unsigned),
//=-----------------------------------------------------------------------------
enum MemberOffset {
- FixedMemberOffset { bytes: uint },
+ FixedMemberOffset { bytes: usize },
// For ComputedMemberOffset, the offset is read from the llvm type definition
ComputedMemberOffset
}
}
let field_size = if self.is_simd {
- machine::llsize_of_alloc(cx, type_of::type_of(cx, self.fields[0].mt.ty)) as uint
+ machine::llsize_of_alloc(cx, type_of::type_of(cx, self.fields[0].mt.ty)) as usize
} else {
0xdeadbeef
};
// DWARF representation of enums uniform.
// First create a description of the artificial wrapper struct:
- let non_null_variant = &(*self.variants)[non_null_variant_index as uint];
+ let non_null_variant = &(*self.variants)[non_null_variant_index as usize];
let non_null_variant_name = token::get_name(non_null_variant.name);
// The llvm type and metadata of the pointer
// Encode the information about the null variant in the union
// member's name.
- let null_variant_index = (1 - non_null_variant_index) as uint;
+ let null_variant_index = (1 - non_null_variant_index) as usize;
let null_variant_name = token::get_name((*self.variants)[null_variant_index].name);
let union_member_name = format!("RUST$ENCODED$ENUM${}${}",
0,
describe_enum_variant(cx,
self.enum_type,
struct_def,
- &*(*self.variants)[nndiscr as uint],
+ &*(*self.variants)[nndiscr as usize],
OptimizedDiscriminant,
self.containing_scope,
self.span);
// Encode the information about the null variant in the union
// member's name.
- let null_variant_index = (1 - nndiscr) as uint;
+ let null_variant_index = (1 - nndiscr) as usize;
let null_variant_name = token::get_name((*self.variants)[null_variant_index].name);
let discrfield = discrfield.iter()
.skip(1)
MemberDescription {
name: "length".to_string(),
llvm_type: member_llvm_types[1],
- type_metadata: type_metadata(cx, cx.tcx().types.uint, span),
+ type_metadata: type_metadata(cx, cx.tcx().types.usize, span),
offset: ComputedMemberOffset,
flags: FLAGS_NONE
},
#[derive(Copy, PartialEq)]
enum InternalDebugLocation {
- KnownLocation { scope: DIScope, line: uint, col: uint },
+ KnownLocation { scope: DIScope, line: usize, col: usize },
UnknownLocation
}
impl InternalDebugLocation {
- fn new(scope: DIScope, line: uint, col: uint) -> InternalDebugLocation {
+ fn new(scope: DIScope, line: usize, col: usize) -> InternalDebugLocation {
KnownLocation {
scope: scope,
line: line,
ty::ty_bool => output.push_str("bool"),
ty::ty_char => output.push_str("char"),
ty::ty_str => output.push_str("str"),
- ty::ty_int(ast::TyIs(_)) => output.push_str("isize"),
+ ty::ty_int(ast::TyIs) => output.push_str("isize"),
ty::ty_int(ast::TyI8) => output.push_str("i8"),
ty::ty_int(ast::TyI16) => output.push_str("i16"),
ty::ty_int(ast::TyI32) => output.push_str("i32"),
ty::ty_int(ast::TyI64) => output.push_str("i64"),
- ty::ty_uint(ast::TyUs(_)) => output.push_str("usize"),
+ ty::ty_uint(ast::TyUs) => output.push_str("usize"),
ty::ty_uint(ast::TyU8) => output.push_str("u8"),
ty::ty_uint(ast::TyU16) => output.push_str("u16"),
ty::ty_uint(ast::TyU32) => output.push_str("u32"),
use trans::type_of;
use middle::ty::{struct_fields, tup_fields};
use middle::ty::{AdjustDerefRef, AdjustReifyFnPointer, AdjustUnsafeFnPointer, AutoUnsafe};
-use middle::ty::{AutoPtr};
+use middle::ty::AutoPtr;
use middle::ty::{self, Ty};
use middle::ty::MethodCall;
use util::common::indenter;
fn unsize_unique_vec<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr,
datum: Datum<'tcx, Expr>,
- len: uint)
+ len: usize)
-> DatumBlock<'blk, 'tcx, Expr> {
let mut bcx = bcx;
let tcx = bcx.tcx();
base: &ast::Expr,
get_idx: F)
-> DatumBlock<'blk, 'tcx, Expr> where
- F: FnOnce(&'blk ty::ctxt<'tcx>, &[ty::field<'tcx>]) -> uint,
+ F: FnOnce(&'blk ty::ctxt<'tcx>, &[ty::field<'tcx>]) -> usize,
{
let mut bcx = bcx;
let _icx = push_ctxt("trans_rec_field");
/// Translates `base.<idx>`.
fn trans_rec_tup_field<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
base: &ast::Expr,
- idx: uint)
+ idx: usize)
-> DatumBlock<'blk, 'tcx, Expr> {
trans_field(bcx, base, |_, _| idx)
}
}
}
ast::ExprTup(ref args) => {
- let numbered_fields: Vec<(uint, &ast::Expr)> =
+ let numbered_fields: Vec<(usize, &ast::Expr)> =
args.iter().enumerate().map(|(i, arg)| (i, &**arg)).collect();
trans_adt(bcx,
expr_ty(bcx, expr),
/// The base expression; will be evaluated after all explicit fields.
expr: &'a ast::Expr,
/// The indices of fields to copy paired with their types.
- fields: Vec<(uint, Ty<'tcx>)>
+ fields: Vec<(usize, Ty<'tcx>)>
}
/// Constructs an ADT instance:
pub fn trans_adt<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
ty: Ty<'tcx>,
discr: ty::Disr,
- fields: &[(uint, &ast::Expr)],
+ fields: &[(usize, &ast::Expr)],
optbase: Option<StructBaseInfo<'a, 'tcx>>,
dest: Dest,
debug_location: DebugLoc)
fn deref_multiple<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
expr: &ast::Expr,
datum: Datum<'tcx, Expr>,
- times: uint)
+ times: usize)
-> DatumBlock<'blk, 'tcx, Expr> {
let mut bcx = bcx;
let mut datum = datum;
}
}
+#[derive(Debug)]
enum OverflowOp {
Add,
Sub,
enum OverflowOpViaInputCheck { Shl, Shr, }
+#[derive(Debug)]
enum OverflowOpViaIntrinsic { Add, Sub, Mul, }
impl OverflowOpViaIntrinsic {
use middle::ty::{ty_int, ty_uint};
let new_sty = match ty.sty {
- ty_int(TyIs(_)) => match &tcx.sess.target.target.target_pointer_width[..] {
+ ty_int(TyIs) => match &tcx.sess.target.target.target_pointer_width[..] {
"32" => ty_int(TyI32),
"64" => ty_int(TyI64),
_ => panic!("unsupported target word size")
},
- ty_uint(TyUs(_)) => match &tcx.sess.target.target.target_pointer_width[..] {
+ ty_uint(TyUs) => match &tcx.sess.target.target.target_pointer_width[..] {
"32" => ty_uint(TyU32),
"64" => ty_uint(TyU64),
_ => panic!("unsupported target word size")
},
ref t @ ty_uint(_) | ref t @ ty_int(_) => t.clone(),
- _ => panic!("tried to get overflow intrinsic for non-int type")
+ _ => panic!("tried to get overflow intrinsic for {:?} applied to non-int type",
+ *self)
};
match *self {
// except according to those terms.
-use back::{link};
+use back::link;
use llvm::{ValueRef, CallConv, get_param};
use llvm;
use middle::weak_lang_items;
use syntax::codemap::Span;
use syntax::parse::token::{InternedString, special_idents};
use syntax::parse::token;
-use syntax::{ast};
+use syntax::ast;
use syntax::{attr, ast_map};
use syntax::print::pprust;
use util::ppaux::Repr;
use middle::subst;
use middle::subst::{Subst, Substs};
use trans::adt;
+use trans::adt::GetDtorType; // for tcx.dtor_type()
use trans::base::*;
use trans::build::*;
use trans::callee;
Load(bcx, llval)
};
let drop_flag = unpack_datum!(bcx, adt::trans_drop_flag_ptr(bcx, &*repr, struct_data));
- with_cond(bcx, load_ty(bcx, drop_flag.val, bcx.tcx().types.bool), |cx| {
+ let loaded = load_ty(bcx, drop_flag.val, bcx.tcx().dtor_type());
+ let drop_flag_llty = type_of(bcx.fcx.ccx, bcx.tcx().dtor_type());
+ let init_val = C_integral(drop_flag_llty, adt::DTOR_NEEDED as u64, false);
+
+ let bcx = if !bcx.ccx().check_drop_flag_for_sanity() {
+ bcx
+ } else {
+ let drop_flag_llty = type_of(bcx.fcx.ccx, bcx.tcx().dtor_type());
+ let done_val = C_integral(drop_flag_llty, adt::DTOR_DONE as u64, false);
+ let not_init = ICmp(bcx, llvm::IntNE, loaded, init_val, DebugLoc::None);
+ let not_done = ICmp(bcx, llvm::IntNE, loaded, done_val, DebugLoc::None);
+ let drop_flag_neither_initialized_nor_cleared =
+ And(bcx, not_init, not_done, DebugLoc::None);
+ with_cond(bcx, drop_flag_neither_initialized_nor_cleared, |cx| {
+ let llfn = cx.ccx().get_intrinsic(&("llvm.debugtrap"));
+ Call(cx, llfn, &[], None, DebugLoc::None);
+ cx
+ })
+ };
+
+ let drop_flag_dtor_needed = ICmp(bcx, llvm::IntEQ, loaded, init_val, DebugLoc::None);
+ with_cond(bcx, drop_flag_dtor_needed, |cx| {
trans_struct_drop(cx, t, v0, dtor_did, class_did, substs)
})
+
}
fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-> Block<'blk, 'tcx> {
// NB: v0 is an *alias* of type t here, not a direct value.
let _icx = push_ctxt("make_drop_glue");
+
+ // Only drop the value when it ... well, we used to check for
+ // non-null, (and maybe we need to continue doing so), but we now
+ // must definitely check for special bit-patterns corresponding to
+ // the special dtor markings.
+
+ let inttype = Type::int(bcx.ccx());
+ let dropped_pattern = C_integral(inttype, adt::dtor_done_usize(bcx.fcx.ccx) as u64, false);
+
match t.sty {
ty::ty_uniq(content_ty) => {
if !type_is_sized(bcx.tcx(), content_ty) {
let llval = GEPi(bcx, v0, &[0, abi::FAT_PTR_ADDR]);
let llbox = Load(bcx, llval);
- let not_null = IsNotNull(bcx, llbox);
- with_cond(bcx, not_null, |bcx| {
+ let llbox_as_usize = PtrToInt(bcx, llbox, Type::int(bcx.ccx()));
+ let drop_flag_not_dropped_already =
+ ICmp(bcx, llvm::IntNE, llbox_as_usize, dropped_pattern, DebugLoc::None);
+ with_cond(bcx, drop_flag_not_dropped_already, |bcx| {
let bcx = drop_ty(bcx, v0, content_ty, DebugLoc::None);
let info = GEPi(bcx, v0, &[0, abi::FAT_PTR_EXTRA]);
let info = Load(bcx, info);
} else {
let llval = v0;
let llbox = Load(bcx, llval);
- let not_null = IsNotNull(bcx, llbox);
- with_cond(bcx, not_null, |bcx| {
+ let llbox_as_usize = PtrToInt(bcx, llbox, inttype);
+ let drop_flag_not_dropped_already =
+ ICmp(bcx, llvm::IntNE, llbox_as_usize, dropped_pattern, DebugLoc::None);
+ with_cond(bcx, drop_flag_not_dropped_already, |bcx| {
let bcx = drop_ty(bcx, llbox, content_ty, DebugLoc::None);
trans_exchange_free_ty(bcx, llbox, content_ty, DebugLoc::None)
})
&format!("transmute called on types with potentially different sizes: \
{} (could be {} bit{}) to {} (could be {} bit{})",
ty_to_string(ccx.tcx(), transmute_restriction.original_from),
- from_type_size as uint,
+ from_type_size as usize,
if from_type_size == 1 {""} else {"s"},
ty_to_string(ccx.tcx(), transmute_restriction.original_to),
- to_type_size as uint,
+ to_type_size as usize,
if to_type_size == 1 {""} else {"s"}));
} else {
ccx.sess().span_err(
&format!("transmute called on types with different sizes: \
{} ({} bit{}) to {} ({} bit{})",
ty_to_string(ccx.tcx(), transmute_restriction.original_from),
- from_type_size as uint,
+ from_type_size as usize,
if from_type_size == 1 {""} else {"s"},
ty_to_string(ccx.tcx(), transmute_restriction.original_to),
- to_type_size as uint,
+ to_type_size as usize,
if to_type_size == 1 {""} else {"s"}));
}
}
&ccx.link_meta().crate_hash);
C_u64(ccx, hash)
}
+ (_, "init_dropped") => {
+ let tp_ty = *substs.types.get(FnSpace, 0);
+ if !return_type_is_void(ccx, tp_ty) {
+ drop_done_fill_mem(bcx, llresult, tp_ty);
+ }
+ C_nil(ccx)
+ }
(_, "init") => {
let tp_ty = *substs.types.get(FnSpace, 0);
if !return_type_is_void(ccx, tp_ty) {
// Just zero out the stack slot. (See comment on base::memzero for explanation)
- zero_mem(bcx, llresult, tp_ty);
+ init_zero_mem(bcx, llresult, tp_ty);
}
C_nil(ccx)
}
false,
false,
*substs.types.get(FnSpace, 0),
- llargs[0],
llargs[1],
+ llargs[0],
llargs[2],
call_debug_location)
}
true,
false,
*substs.types.get(FnSpace, 0),
- llargs[0],
llargs[1],
+ llargs[0],
llargs[2],
call_debug_location)
}
}
}
-pub fn llelement_offset(cx: &CrateContext, struct_ty: Type, element: uint) -> u64 {
+pub fn llelement_offset(cx: &CrateContext, struct_ty: Type, element: usize) -> u64 {
unsafe {
return llvm::LLVMOffsetOfElement(cx.td().lltd, struct_ty.to_ref(),
element as u32);
use back::link;
use llvm::{ValueRef, get_param};
use metadata::csearch;
-use middle::subst::Substs;
+use middle::subst::{Subst, Substs};
use middle::subst::VecPerParamSpace;
use middle::subst;
use middle::traits;
use syntax::ptr::P;
// drop_glue pointer, size, align.
-const VTABLE_OFFSET: uint = 3;
+const VTABLE_OFFSET: usize = 3;
/// The main "translation" pass for methods. Generates code
/// for non-monomorphized methods only. Other methods will
fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
method_call: MethodCall,
trait_id: ast::DefId,
- n_method: uint,
+ n_method: usize,
vtable: traits::Vtable<'tcx, ()>)
-> Callee<'blk, 'tcx> {
let _icx = push_ctxt("meth::trans_monomorphized_callee");
/// extract the self data and vtable out of the pair.
fn trans_trait_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
method_ty: Ty<'tcx>,
- vtable_index: uint,
+ vtable_index: usize,
self_expr: &ast::Expr,
arg_cleanup_scope: cleanup::ScopeId)
-> Callee<'blk, 'tcx> {
/// pair.
pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
callee_ty: Ty<'tcx>,
- vtable_index: uint,
+ vtable_index: usize,
llpair: ValueRef)
-> Callee<'blk, 'tcx> {
let _icx = push_ctxt("meth::trans_trait_callee");
ccx: &'a CrateContext<'a, 'tcx>,
object_ty: Ty<'tcx>,
upcast_trait_ref: ty::PolyTraitRef<'tcx>,
- method_offset_in_trait: uint)
+ method_offset_in_trait: usize)
-> (ValueRef, Ty<'tcx>)
{
let _icx = push_ctxt("trans_object_shim");
ty::populate_implementations_for_trait_if_necessary(tcx, trt_id);
+ let nullptr = C_null(Type::nil(ccx).ptr_to());
let trait_item_def_ids = ty::trait_item_def_ids(tcx, trt_id);
trait_item_def_ids
.iter()
};
let name = trait_method_type.name;
+ // Some methods cannot be called on an object; skip those.
+ if !traits::is_vtable_safe_method(tcx, trt_id, &trait_method_type) {
+ debug!("emit_vtable_methods: not vtable safe");
+ return nullptr;
+ }
+
debug!("emit_vtable_methods: trait_method_type={}",
trait_method_type.repr(tcx));
ty::TypeTraitItem(_) => ccx.sess().bug("should be a method, not assoc type")
};
- debug!("emit_vtable_methods: m={}",
+ debug!("emit_vtable_methods: impl_method_type={}",
impl_method_type.repr(tcx));
- let nullptr = C_null(Type::nil(ccx).ptr_to());
-
- if impl_method_type.generics.has_type_params(subst::FnSpace) {
- debug!("emit_vtable_methods: generic");
- return nullptr;
- }
-
- let bare_fn_ty =
- ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(impl_method_type.fty.clone()));
- if ty::type_has_self(bare_fn_ty) {
- debug!("emit_vtable_methods: type_has_self {}",
- bare_fn_ty.repr(tcx));
- return nullptr;
- }
-
// If this is a default method, it's possible that it
// relies on where clauses that do not hold for this
// particular set of type parameters. Note that this
// method could then never be called, so we do not want to
// try and trans it, in that case. Issue #23435.
if ty::provided_source(tcx, impl_method_def_id).is_some() {
- let predicates =
- monomorphize::apply_param_substs(tcx,
- &substs,
- &impl_method_type.predicates.predicates);
- if !predicates_hold(ccx, predicates.into_vec()) {
+ let predicates = impl_method_type.predicates.predicates.subst(tcx, &substs);
+ if !normalize_and_test_predicates(ccx, predicates.into_vec()) {
debug!("emit_vtable_methods: predicates do not hold");
return nullptr;
}
use back::abi;
use llvm;
-use llvm::{ValueRef};
+use llvm::ValueRef;
use trans::base::*;
use trans::base;
use trans::build::*;
}
}
-fn elements_required(bcx: Block, content_expr: &ast::Expr) -> uint {
+fn elements_required(bcx: Block, content_expr: &ast::Expr) -> usize {
//! Figure out the number of elements we need to store this content
match content_expr.node {
/// which should be by ref.
pub fn get_fixed_base_and_len(bcx: Block,
llval: ValueRef,
- vec_length: uint)
+ vec_length: usize)
-> (ValueRef, ValueRef) {
let ccx = bcx.ccx();
pub fn int_from_ty(ccx: &CrateContext, t: ast::IntTy) -> Type {
match t {
- ast::TyIs(_) => ccx.int_type(),
+ ast::TyIs => ccx.int_type(),
ast::TyI8 => Type::i8(ccx),
ast::TyI16 => Type::i16(ccx),
ast::TyI32 => Type::i32(ccx),
pub fn uint_from_ty(ccx: &CrateContext, t: ast::UintTy) -> Type {
match t {
- ast::TyUs(_) => ccx.int_type(),
+ ast::TyUs => ccx.int_type(),
ast::TyU8 => Type::i8(ccx),
ast::TyU16 => Type::i16(ccx),
ast::TyU32 => Type::i32(ccx),
}
/// Return the number of elements in `self` if it is a LLVM vector type.
- pub fn vector_length(&self) -> uint {
+ pub fn vector_length(&self) -> usize {
unsafe {
- llvm::LLVMGetVectorSize(self.to_ref()) as uint
+ llvm::LLVMGetVectorSize(self.to_ref()) as usize
}
}
- pub fn array_length(&self) -> uint {
+ pub fn array_length(&self) -> usize {
unsafe {
- llvm::LLVMGetArrayLength(self.to_ref()) as uint
+ llvm::LLVMGetArrayLength(self.to_ref()) as usize
}
}
pub fn field_types(&self) -> Vec<Type> {
unsafe {
- let n_elts = llvm::LLVMCountStructElementTypes(self.to_ref()) as uint;
+ let n_elts = llvm::LLVMCountStructElementTypes(self.to_ref()) as usize;
if n_elts == 0 {
return Vec::new();
}
pub fn func_params(&self) -> Vec<Type> {
unsafe {
- let n_args = llvm::LLVMCountParamTypes(self.to_ref()) as uint;
+ let n_args = llvm::LLVMCountParamTypes(self.to_ref()) as usize;
let mut args: Vec<_> = repeat(Type { rf: ptr::null_mut() }).take(n_args).collect();
llvm::LLVMGetParamTypes(self.to_ref(),
args.as_mut_ptr() as *mut TypeRef);
}
}
- pub fn float_width(&self) -> uint {
+ pub fn float_width(&self) -> usize {
match self.kind() {
Float => 32,
Double => 64,
use trans::type_::Type;
+#[allow(deprecated)]
use std::num::Int;
use syntax::abi;
use syntax::ast;
let unsized_part = unsized_part_of_type(cx.tcx(), ty);
let info_ty = match unsized_part.sty {
ty::ty_str | ty::ty_vec(..) => {
- Type::uint_from_ty(cx, ast::TyUs(false))
+ Type::uint_from_ty(cx, ast::TyUs)
}
ty::ty_trait(_) => Type::vtable_ptr(cx),
_ => panic!("Unexpected type returned from \
/// Returns the requested operand of this instruction
/// Returns None, if there's no operand at the given index
- pub fn get_operand(self, i: uint) -> Option<Value> {
+ pub fn get_operand(self, i: usize) -> Option<Value> {
opt_val!(llvm::LLVMGetOperand(self.get(), i as c_uint))
}
/// (if one exists) and a vector of the (pattern, number of lifetimes)
/// corresponding to each input type/pattern.
fn find_implied_output_region(input_tys: &[Ty], input_pats: Vec<String>)
- -> (Option<ty::Region>, Vec<(String, uint)>)
+ -> (Option<ty::Region>, Vec<(String, usize)>)
{
- let mut lifetimes_for_params: Vec<(String, uint)> = Vec::new();
+ let mut lifetimes_for_params: Vec<(String, usize)> = Vec::new();
let mut possible_implied_output_region = None;
for (input_type, input_pat) in input_tys.iter().zip(input_pats.into_iter()) {
fn convert_ty_with_lifetime_elision<'tcx>(this: &AstConv<'tcx>,
implied_output_region: Option<ty::Region>,
- param_lifetimes: Vec<(String, uint)>,
+ param_lifetimes: Vec<(String, usize)>,
ty: &ast::Ty)
-> Ty<'tcx>
{
ty
}
ast::TyFixedLengthVec(ref ty, ref e) => {
- match const_eval::eval_const_expr_partial(tcx, &**e, Some(tcx.types.uint)) {
+ match const_eval::eval_const_expr_partial(tcx, &**e, Some(tcx.types.usize)) {
Ok(r) => {
match r {
const_eval::const_int(i) =>
ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty),
- Some(i as uint)),
+ Some(i as usize)),
const_eval::const_uint(i) =>
ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty),
- Some(i as uint)),
+ Some(i as usize)),
_ => {
span_err!(tcx.sess, ast_ty.span, E0249,
"expected constant expr for array length");
}
};
- fn count_modifiers(ty: Ty) -> uint {
+ fn count_modifiers(ty: Ty) -> usize {
match ty.sty {
ty::ty_rptr(_, mt) => count_modifiers(mt.ty) + 1,
ty::ty_uniq(t) => count_modifiers(t) + 1,
use middle::def;
use middle::infer;
use middle::pat_util::{PatIdMap, pat_id_map, pat_is_binding, pat_is_const};
-use middle::subst::{Substs};
+use middle::subst::Substs;
use middle::ty::{self, Ty};
use check::{check_expr, check_expr_has_type, check_expr_with_expectation};
use check::{check_expr_coercable_to_type, demand, FnCtxt, Expectation};
// except according to those terms.
use super::autoderef;
-use super::AutorefArgs;
use super::check_argument_types;
use super::check_expr;
use super::check_method_argument_types;
&fn_sig.inputs,
&expected_arg_tys[..],
arg_exprs,
- AutorefArgs::No,
fn_sig.variadic,
TupleArgumentsFlag::DontTupleArguments);
&*fn_sig.inputs,
&*expected_arg_tys,
arg_exprs,
- AutorefArgs::No,
fn_sig.variadic,
TupleArgumentsFlag::TupleArguments);
method_callee.ty,
callee_expr,
arg_exprs,
- AutorefArgs::No,
TupleArgumentsFlag::TupleArguments,
expected);
write_call(fcx, call_expr, output_type);
use util::ppaux::{self, Repr};
use syntax::ast;
-use syntax::codemap::{Span};
+use syntax::codemap::Span;
use syntax::parse::token;
use super::assoc;
ty_root: ty::Ty<'tcx>,
span: Span,
scope: region::CodeExtent,
- depth: uint,
- xref_depth: uint) -> Result<(), Error<'tcx>>
+ depth: usize,
+ xref_depth: usize) -> Result<(), Error<'tcx>>
{
// Issue #22443: Watch out for overflow. While we are careful to
// handle regular types properly, non-regular ones cause problems.
use astconv::object_region_bounds;
use middle::infer::{InferCtxt, GenericKind};
-use middle::subst::{Substs};
+use middle::subst::Substs;
use middle::traits;
use middle::ty::{self, ToPolyTraitRef, Ty};
use middle::ty_fold::{TypeFoldable, TypeFolder};
//! Method lookup: the secret sauce of Rust. See `README.md`.
use astconv::AstConv;
-use check::{FnCtxt};
+use check::FnCtxt;
use check::vtable;
use check::vtable::select_new_fcx_obligations;
use middle::def;
use util::ppaux::Repr;
use std::rc::Rc;
-use syntax::ast::{DefId};
+use syntax::ast::DefId;
use syntax::ast;
use syntax::codemap::Span;
TraitSource(/* trait id */ ast::DefId),
}
-type MethodIndex = uint; // just for doc purposes
+type MethodIndex = usize; // just for doc purposes
/// Determines whether the type `self_ty` supports a method name `method_name` or not.
pub fn exists<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
fn trait_method<'tcx>(tcx: &ty::ctxt<'tcx>,
trait_def_id: ast::DefId,
method_name: ast::Name)
- -> Option<(uint, Rc<ty::Method<'tcx>>)>
+ -> Option<(usize, Rc<ty::Method<'tcx>>)>
{
let trait_items = ty::trait_items(tcx, trait_def_id);
trait_items
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::{MethodError};
+use super::MethodError;
use super::MethodIndex;
use super::{CandidateSource,ImplSource,TraitSource};
use super::suggest;
enum CandidateKind<'tcx> {
InherentImplCandidate(/* Impl */ ast::DefId, subst::Substs<'tcx>),
- ObjectCandidate(/* Trait */ ast::DefId, /* method_num */ uint, /* vtable index */ uint),
+ ObjectCandidate(/* Trait */ ast::DefId, /* method_num */ usize, /* vtable index */ usize),
ExtensionImplCandidate(/* Impl */ ast::DefId, Rc<ty::TraitRef<'tcx>>,
subst::Substs<'tcx>, MethodIndex),
ClosureCandidate(/* Trait */ ast::DefId, MethodIndex),
#[derive(Clone,Debug)]
pub enum PickKind<'tcx> {
InherentImplPick(/* Impl */ ast::DefId),
- ObjectPick(/* Trait */ ast::DefId, /* method_num */ uint, /* real_index */ uint),
+ ObjectPick(/* Trait */ ast::DefId, /* method_num */ usize, /* real_index */ usize),
ExtensionImplPick(/* Impl */ ast::DefId, MethodIndex),
TraitPick(/* Trait */ ast::DefId, MethodIndex),
WhereClausePick(/* Trait */ ty::PolyTraitRef<'tcx>, MethodIndex),
// Indicates that the source expression should be autoderef'd N times
//
// A = expr | *expr | **expr
- AutoDeref(uint),
+ AutoDeref(usize),
// Indicates that the source expression should be autoderef'd N
// times and then "unsized". This should probably eventually go
// away in favor of just coercing method receivers.
//
// A = unsize(expr | *expr | **expr)
- AutoUnsizeLength(/* number of autoderefs */ uint, /* length*/ uint),
+ AutoUnsizeLength(/* number of autoderefs */ usize, /* length*/ usize),
// Indicates that an autoref is applied after some number of other adjustments
//
let lang_def_id = self.tcx().lang_items.i64_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::ty_int(ast::TyIs(_)) => {
+ ty::ty_int(ast::TyIs) => {
let lang_def_id = self.tcx().lang_items.isize_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
let lang_def_id = self.tcx().lang_items.u64_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
- ty::ty_uint(ast::TyUs(_)) => {
+ ty::ty_uint(ast::TyUs) => {
let lang_def_id = self.tcx().lang_items.usize_impl();
self.assemble_inherent_impl_for_primitive(lang_def_id);
}
&mut ProbeContext<'b, 'tcx>,
ty::PolyTraitRef<'tcx>,
Rc<ty::Method<'tcx>>,
- uint,
+ usize,
),
{
debug!("elaborate_bounds(bounds={})", bounds.repr(self.tcx()));
fn assemble_extension_candidates_for_trait_impls(&mut self,
trait_def_id: ast::DefId,
method: Rc<ty::Method<'tcx>>,
- method_index: uint)
+ method_index: usize)
{
ty::populate_implementations_for_trait_if_necessary(self.tcx(),
trait_def_id);
fn assemble_closure_candidates(&mut self,
trait_def_id: ast::DefId,
method_ty: Rc<ty::Method<'tcx>>,
- method_index: uint)
+ method_index: usize)
-> Result<(),MethodError>
{
// Check if this is one of the Fn,FnMut,FnOnce traits.
fn assemble_projection_candidates(&mut self,
trait_def_id: ast::DefId,
method: Rc<ty::Method<'tcx>>,
- method_index: uint)
+ method_index: usize)
{
debug!("assemble_projection_candidates(\
trait_def_id={}, \
fn assemble_where_clause_candidates(&mut self,
trait_def_id: ast::DefId,
method_ty: Rc<ty::Method<'tcx>>,
- method_index: uint)
+ method_index: usize)
{
debug!("assemble_where_clause_candidates(trait_def_id={})",
trait_def_id.repr(self.tcx()));
return self.pick_method(step.self_ty).map(|r| self.adjust(r, adjustment.clone()));
- fn consider_reborrow<'tcx>(ty: Ty<'tcx>, d: uint) -> PickAdjustment {
+ fn consider_reborrow<'tcx>(ty: Ty<'tcx>, d: usize) -> PickAdjustment {
// Insert a `&*` or `&mut *` if this is a reference type:
match ty.sty {
ty::ty_rptr(_, ref mt) => AutoRef(mt.mutbl, box AutoDeref(d+1)),
/// ```
/// trait Foo { ... }
/// impl Foo for Vec<int> { ... }
- /// impl Foo for Vec<uint> { ... }
+ /// impl Foo for Vec<usize> { ... }
/// ```
///
/// Now imagine the receiver is `Vec<_>`. It doesn't really matter at this time which impl we
fn trait_method<'tcx>(tcx: &ty::ctxt<'tcx>,
trait_def_id: ast::DefId,
method_name: ast::Name)
- -> Option<(uint, Rc<ty::Method<'tcx>>)>
+ -> Option<(usize, Rc<ty::Method<'tcx>>)>
{
let trait_items = ty::trait_items(tcx, trait_def_id);
debug!("trait_method; items: {:?}", trait_items);
pub use self::LvaluePreference::*;
pub use self::Expectation::*;
pub use self::compare_method::compare_impl_method;
-use self::IsBinopAssignment::*;
use self::TupleArgumentsFlag::*;
use astconv::{self, ast_region_to_region, ast_ty_to_ty, AstConv, PathParamMode};
mod closure;
mod callee;
mod compare_method;
+mod op;
/// closures defined within the function. For example:
///
}
}
-/// Whether `check_binop` is part of an assignment or not.
-/// Used to know whether we allow user overloads and to print
-/// better messages on error.
-#[derive(PartialEq)]
-enum IsBinopAssignment{
- SimpleBinop,
- BinopAssignment,
-}
-
#[derive(Clone)]
pub struct FnCtxt<'a, 'tcx: 'a> {
body_id: ast::NodeId,
// checking this function. On exit, if we find that *more* errors
// have been reported, we will skip regionck and other work that
// expects the types within the function to be consistent.
- err_count_on_creation: uint,
+ err_count_on_creation: usize,
ret_ty: ty::FnOutput<'tcx>,
fn visit_ty(&mut self, t: &'tcx ast::Ty) {
match t.node {
ast::TyFixedLengthVec(_, ref expr) => {
- check_const_in_type(self.ccx, &**expr, self.ccx.tcx.types.uint);
+ check_const_in_type(self.ccx, &**expr, self.ccx.tcx.types.usize);
}
_ => {}
}
match t.node {
ast::TyFixedLengthVec(ref ty, ref count_expr) => {
self.visit_ty(&**ty);
- check_expr_with_hint(self.fcx, &**count_expr, self.fcx.tcx().types.uint);
+ check_expr_with_hint(self.fcx, &**count_expr, self.fcx.tcx().types.usize);
}
_ => visit::walk_ty(self, t)
}
fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_NUMERIC_CASTS,
e.id,
span,
- format!("trivial numeric cast: `{}` as `{}`",
+ format!("trivial numeric cast: `{}` as `{}`. Cast can be \
+ replaced by coercion, this might require type \
+ ascription or a temporary variable",
fcx.infcx().ty_to_string(t_e),
fcx.infcx().ty_to_string(t_1)));
} else {
fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_CASTS,
e.id,
span,
- format!("trivial cast: `{}` as `{}`",
+ format!("trivial cast: `{}` as `{}`. Cast can be \
+ replaced by coercion, this might require type \
+ ascription or a temporary variable",
fcx.infcx().ty_to_string(t_e),
fcx.infcx().ty_to_string(t_1)));
}
&self.tcx().sess
}
- pub fn err_count_since_creation(&self) -> uint {
+ pub fn err_count_since_creation(&self) -> usize {
self.ccx.tcx.sess.err_count() - self.err_count_on_creation
}
/// version, this version will also select obligations if it seems
/// useful, in an effort to get more type information.
fn resolve_type_vars_if_possible(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
+ debug!("resolve_type_vars_if_possible(ty={})", ty.repr(self.tcx()));
+
// No ty::infer()? Nothing needs doing.
if !ty::type_has_ty_infer(ty) {
+ debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
return ty;
}
// If `ty` is a type variable, see whether we already know what it is.
ty = self.infcx().resolve_type_vars_if_possible(&ty);
if !ty::type_has_ty_infer(ty) {
+ debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
return ty;
}
vtable::select_new_fcx_obligations(self);
ty = self.infcx().resolve_type_vars_if_possible(&ty);
if !ty::type_has_ty_infer(ty) {
+ debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
return ty;
}
// indirect dependencies that don't seem worth tracking
// precisely.
vtable::select_fcx_obligations_where_possible(self);
- self.infcx().resolve_type_vars_if_possible(&ty)
+ ty = self.infcx().resolve_type_vars_if_possible(&ty);
+
+ debug!("resolve_type_vars_if_possible: ty={}", ty.repr(self.tcx()));
+ ty
}
/// Resolves all type variables in `t` and then, if any were left
pub fn write_autoderef_adjustment(&self,
node_id: ast::NodeId,
span: Span,
- derefs: uint) {
+ derefs: usize) {
if derefs == 0 { return; }
self.write_adjustment(
node_id,
span: Span,
class_id: ast::DefId,
items: &[ty::field_ty],
- idx: uint,
+ idx: usize,
substs: &subst::Substs<'tcx>)
-> Option<Ty<'tcx>>
{
Some(self.infcx().next_region_var(infer::MiscVariable(span)))
}
- fn anon_regions(&self, span: Span, count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>> {
+ fn anon_regions(&self, span: Span, count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>> {
Ok((0..count).map(|_| {
self.infcx().next_region_var(infer::MiscVariable(span))
}).collect())
unresolved_type_action: UnresolvedTypeAction,
mut lvalue_pref: LvaluePreference,
mut should_stop: F)
- -> (Ty<'tcx>, uint, Option<T>)
- where F: FnMut(Ty<'tcx>, uint) -> Option<T>,
+ -> (Ty<'tcx>, usize, Option<T>)
+ where F: FnMut(Ty<'tcx>, usize) -> Option<T>,
{
debug!("autoderef(base_ty={}, opt_expr={}, lvalue_pref={:?})",
base_ty.repr(fcx.tcx()),
{
match method {
Some(method) => {
- let ref_ty = // invoked methods have all LB regions instantiated
- ty::no_late_bound_regions(
- fcx.tcx(), &ty::ty_fn_ret(method.ty)).unwrap();
- match method_call {
- Some(method_call) => {
- fcx.inh.method_map.borrow_mut().insert(method_call,
- method);
- }
- None => {}
- }
- match ref_ty {
- ty::FnConverging(ref_ty) => {
- ty::deref(ref_ty, true)
- }
- ty::FnDiverging => {
- fcx.tcx().sess.bug("index/deref traits do not define a `!` return")
- }
+ // extract method method return type, which will be &T;
+ // all LB regions should have been instantiated during method lookup
+ let ret_ty = ty::ty_fn_ret(method.ty);
+ let ret_ty = ty::no_late_bound_regions(fcx.tcx(), &ret_ty).unwrap().unwrap();
+
+ if let Some(method_call) = method_call {
+ fcx.inh.method_map.borrow_mut().insert(method_call, method);
}
+
+ // method returns &T, but the type as visible to user is T, so deref
+ ty::deref(ret_ty, true)
}
None => None,
}
// First, try built-in indexing.
match (ty::index(adjusted_ty), &index_ty.sty) {
- (Some(ty), &ty::ty_uint(ast::TyUs(_))) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => {
+ (Some(ty), &ty::ty_uint(ast::TyUs)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => {
debug!("try_index_step: success, using built-in indexing");
fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment));
- return Some((tcx.types.uint, ty));
+ return Some((tcx.types.usize, ty));
}
_ => {}
}
method_fn_ty: Ty<'tcx>,
callee_expr: &'tcx ast::Expr,
args_no_rcvr: &'tcx [P<ast::Expr>],
- autoref_args: AutorefArgs,
tuple_arguments: TupleArgumentsFlag,
expected: Expectation<'tcx>)
-> ty::FnOutput<'tcx> {
&err_inputs[..],
&[],
args_no_rcvr,
- autoref_args,
false,
tuple_arguments);
ty::FnConverging(fcx.tcx().types.err)
&fty.sig.0.inputs[1..],
&expected_arg_tys[..],
args_no_rcvr,
- autoref_args,
fty.sig.0.variadic,
tuple_arguments);
fty.sig.0.output
fn_inputs: &[Ty<'tcx>],
expected_arg_tys: &[Ty<'tcx>],
args: &'tcx [P<ast::Expr>],
- autoref_args: AutorefArgs,
variadic: bool,
tuple_arguments: TupleArgumentsFlag) {
let tcx = fcx.ccx.tcx;
if is_block == check_blocks {
debug!("checking the argument");
- let mut formal_ty = formal_tys[i];
-
- match autoref_args {
- AutorefArgs::Yes => {
- match formal_ty.sty {
- ty::ty_rptr(_, mt) => formal_ty = mt.ty,
- ty::ty_err => (),
- _ => {
- // So we hit this case when one implements the
- // operator traits but leaves an argument as
- // just T instead of &T. We'll catch it in the
- // mismatch impl/trait method phase no need to
- // ICE here.
- // See: #11450
- formal_ty = tcx.types.err;
- }
- }
- }
- AutorefArgs::No => {}
- }
+ let formal_ty = formal_tys[i];
// The special-cased logic below has three functions:
// 1. Provide as good of an expected type as possible.
}
// FIXME(#17596) Ty<'tcx> is incorrectly invariant w.r.t 'tcx.
-fn err_args<'tcx>(tcx: &ty::ctxt<'tcx>, len: uint) -> Vec<Ty<'tcx>> {
+fn err_args<'tcx>(tcx: &ty::ctxt<'tcx>, len: usize) -> Vec<Ty<'tcx>> {
(0..len).map(|_| tcx.types.err).collect()
}
match ty.sty {
ty::ty_int(_) | ty::ty_uint(_) => Some(ty),
ty::ty_char => Some(tcx.types.u8),
- ty::ty_ptr(..) => Some(tcx.types.uint),
- ty::ty_bare_fn(..) => Some(tcx.types.uint),
+ ty::ty_ptr(..) => Some(tcx.types.usize),
+ ty::ty_bare_fn(..) => Some(tcx.types.usize),
_ => None
}
});
TypeAndSubsts { substs: substs, ty: substd_ty }
}
-// Controls whether the arguments are automatically referenced. This is useful
-// for overloaded binary and unary operators.
-#[derive(Copy, PartialEq)]
-pub enum AutorefArgs {
- Yes,
- No,
-}
-
/// Controls whether the arguments are tupled. This is used for the call
/// operator.
///
/// passed as a single parameter. For example, if tupling is enabled, this
/// function:
///
-/// fn f(x: (int, int))
+/// fn f(x: (isize, isize))
///
/// Can be called as:
///
fn_ty,
expr,
&args[1..],
- AutorefArgs::No,
DontTupleArguments,
expected);
fcx.write_ty(id, if_ty);
}
- fn lookup_op_method<'a, 'tcx, F>(fcx: &'a FnCtxt<'a, 'tcx>,
- op_ex: &'tcx ast::Expr,
- lhs_ty: Ty<'tcx>,
- opname: ast::Name,
- trait_did: Option<ast::DefId>,
- lhs: &'a ast::Expr,
- rhs: Option<&'tcx P<ast::Expr>>,
- unbound_method: F,
- autoref_args: AutorefArgs) -> Ty<'tcx> where
- F: FnOnce(),
- {
- let method = match trait_did {
- Some(trait_did) => {
- // We do eager coercions to make using operators
- // more ergonomic:
- //
- // - If the input is of type &'a T (resp. &'a mut T),
- // then reborrow it to &'b T (resp. &'b mut T) where
- // 'b <= 'a. This makes things like `x == y`, where
- // `x` and `y` are both region pointers, work. We
- // could also solve this with variance or different
- // traits that don't force left and right to have same
- // type.
- let (adj_ty, adjustment) = match lhs_ty.sty {
- ty::ty_rptr(r_in, mt) => {
- let r_adj = fcx.infcx().next_region_var(infer::Autoref(lhs.span));
- fcx.mk_subr(infer::Reborrow(lhs.span), r_adj, *r_in);
- let adjusted_ty = ty::mk_rptr(fcx.tcx(), fcx.tcx().mk_region(r_adj), mt);
- let autoptr = ty::AutoPtr(r_adj, mt.mutbl, None);
- let adjustment = ty::AutoDerefRef { autoderefs: 1, autoref: Some(autoptr) };
- (adjusted_ty, adjustment)
- }
- _ => {
- (lhs_ty, ty::AutoDerefRef { autoderefs: 0, autoref: None })
- }
- };
-
- debug!("adjusted_ty={} adjustment={:?}",
- adj_ty.repr(fcx.tcx()),
- adjustment);
-
- method::lookup_in_trait_adjusted(fcx, op_ex.span, Some(lhs), opname,
- trait_did, adjustment, adj_ty, None)
- }
- None => None
- };
- let args = match rhs {
- Some(rhs) => slice::ref_slice(rhs),
- None => &[][..]
- };
- match method {
- Some(method) => {
- let method_ty = method.ty;
- // HACK(eddyb) Fully qualified path to work around a resolve bug.
- let method_call = ::middle::ty::MethodCall::expr(op_ex.id);
- fcx.inh.method_map.borrow_mut().insert(method_call, method);
- match check_method_argument_types(fcx,
- op_ex.span,
- method_ty,
- op_ex,
- args,
- autoref_args,
- DontTupleArguments,
- NoExpectation) {
- ty::FnConverging(result_type) => result_type,
- ty::FnDiverging => fcx.tcx().types.err
- }
- }
- None => {
- unbound_method();
- // Check the args anyway
- // so we get all the error messages
- let expected_ty = fcx.tcx().types.err;
- check_method_argument_types(fcx,
- op_ex.span,
- expected_ty,
- op_ex,
- args,
- autoref_args,
- DontTupleArguments,
- NoExpectation);
- fcx.tcx().types.err
- }
- }
- }
-
- // could be either an expr_binop or an expr_assign_binop
- fn check_binop<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
- expr: &'tcx ast::Expr,
- op: ast::BinOp,
- lhs: &'tcx ast::Expr,
- rhs: &'tcx P<ast::Expr>,
- is_binop_assignment: IsBinopAssignment) {
- let tcx = fcx.ccx.tcx;
-
- let lvalue_pref = match is_binop_assignment {
- BinopAssignment => PreferMutLvalue,
- SimpleBinop => NoPreference
- };
- check_expr_with_lvalue_pref(fcx, lhs, lvalue_pref);
-
- // Callee does bot / err checking
- let lhs_t =
- structurally_resolve_type_or_else(fcx, lhs.span, fcx.expr_ty(lhs), || {
- if ast_util::is_symmetric_binop(op.node) {
- // Try RHS first
- check_expr(fcx, &**rhs);
- fcx.expr_ty(&**rhs)
- } else {
- fcx.tcx().types.err
- }
- });
-
- if ty::type_is_integral(lhs_t) && ast_util::is_shift_binop(op.node) {
- // Shift is a special case: rhs must be uint, no matter what lhs is
- check_expr(fcx, &**rhs);
- let rhs_ty = fcx.expr_ty(&**rhs);
- let rhs_ty = structurally_resolved_type(fcx, rhs.span, rhs_ty);
- if ty::type_is_integral(rhs_ty) {
- fcx.write_ty(expr.id, lhs_t);
- } else {
- fcx.type_error_message(
- expr.span,
- |actual| {
- format!(
- "right-hand-side of a shift operation must have integral type, \
- not `{}`",
- actual)
- },
- rhs_ty,
- None);
- fcx.write_ty(expr.id, fcx.tcx().types.err);
- }
- return;
- }
-
- if ty::is_binopable(tcx, lhs_t, op) {
- let tvar = fcx.infcx().next_ty_var();
- demand::suptype(fcx, expr.span, tvar, lhs_t);
- check_expr_has_type(fcx, &**rhs, tvar);
-
- let result_t = match op.node {
- ast::BiEq | ast::BiNe | ast::BiLt | ast::BiLe | ast::BiGe |
- ast::BiGt => {
- if ty::type_is_simd(tcx, lhs_t) {
- if ty::type_is_fp(ty::simd_type(tcx, lhs_t)) {
- fcx.type_error_message(expr.span,
- |actual| {
- format!("binary comparison \
- operation `{}` not \
- supported for floating \
- point SIMD vector `{}`",
- ast_util::binop_to_string(op.node),
- actual)
- },
- lhs_t,
- None
- );
- fcx.tcx().types.err
- } else {
- lhs_t
- }
- } else {
- fcx.tcx().types.bool
- }
- },
- _ => lhs_t,
- };
-
- fcx.write_ty(expr.id, result_t);
- return;
- }
-
- if op.node == ast::BiOr || op.node == ast::BiAnd {
- // This is an error; one of the operands must have the wrong
- // type
- fcx.write_error(expr.id);
- fcx.write_error(rhs.id);
- fcx.type_error_message(expr.span,
- |actual| {
- format!("binary operation `{}` cannot be applied \
- to type `{}`",
- ast_util::binop_to_string(op.node),
- actual)
- },
- lhs_t,
- None)
- }
-
- // Check for overloaded operators if not an assignment.
- let result_t = if is_binop_assignment == SimpleBinop {
- check_user_binop(fcx, expr, lhs, lhs_t, op, rhs)
- } else {
- fcx.type_error_message(expr.span,
- |actual| {
- format!("binary assignment \
- operation `{}=` \
- cannot be applied to \
- type `{}`",
- ast_util::binop_to_string(op.node),
- actual)
- },
- lhs_t,
- None);
- check_expr(fcx, &**rhs);
- fcx.tcx().types.err
- };
-
- fcx.write_ty(expr.id, result_t);
- if ty::type_is_error(result_t) {
- fcx.write_ty(rhs.id, result_t);
- }
- }
-
- fn check_user_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- ex: &'tcx ast::Expr,
- lhs_expr: &'tcx ast::Expr,
- lhs_resolved_t: Ty<'tcx>,
- op: ast::BinOp,
- rhs: &'tcx P<ast::Expr>) -> Ty<'tcx> {
- let tcx = fcx.ccx.tcx;
- let lang = &tcx.lang_items;
- let (name, trait_did) = match op.node {
- ast::BiAdd => ("add", lang.add_trait()),
- ast::BiSub => ("sub", lang.sub_trait()),
- ast::BiMul => ("mul", lang.mul_trait()),
- ast::BiDiv => ("div", lang.div_trait()),
- ast::BiRem => ("rem", lang.rem_trait()),
- ast::BiBitXor => ("bitxor", lang.bitxor_trait()),
- ast::BiBitAnd => ("bitand", lang.bitand_trait()),
- ast::BiBitOr => ("bitor", lang.bitor_trait()),
- ast::BiShl => ("shl", lang.shl_trait()),
- ast::BiShr => ("shr", lang.shr_trait()),
- ast::BiLt => ("lt", lang.ord_trait()),
- ast::BiLe => ("le", lang.ord_trait()),
- ast::BiGe => ("ge", lang.ord_trait()),
- ast::BiGt => ("gt", lang.ord_trait()),
- ast::BiEq => ("eq", lang.eq_trait()),
- ast::BiNe => ("ne", lang.eq_trait()),
- ast::BiAnd | ast::BiOr => {
- check_expr(fcx, &**rhs);
- return tcx.types.err;
- }
- };
- lookup_op_method(fcx, ex, lhs_resolved_t, token::intern(name),
- trait_did, lhs_expr, Some(rhs), || {
- fcx.type_error_message(ex.span, |actual| {
- format!("binary operation `{}` cannot be applied to type `{}`",
- ast_util::binop_to_string(op.node),
- actual)
- }, lhs_resolved_t, None)
- }, if ast_util::is_by_value_binop(op.node) { AutorefArgs::No } else { AutorefArgs::Yes })
- }
-
- fn check_user_unop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- op_str: &str,
- mname: &str,
- trait_did: Option<ast::DefId>,
- ex: &'tcx ast::Expr,
- rhs_expr: &'tcx ast::Expr,
- rhs_t: Ty<'tcx>,
- op: ast::UnOp) -> Ty<'tcx> {
- lookup_op_method(fcx, ex, rhs_t, token::intern(mname),
- trait_did, rhs_expr, None, || {
- fcx.type_error_message(ex.span, |actual| {
- format!("cannot apply unary operator `{}` to type `{}`",
- op_str, actual)
- }, rhs_t, None);
- }, if ast_util::is_by_value_unop(op) { AutorefArgs::No } else { AutorefArgs::Yes })
- }
-
// Check field access expressions
fn check_field<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
expr: &'tcx ast::Expr,
expr: &'tcx ast::Expr,
lvalue_pref: LvaluePreference,
base: &'tcx ast::Expr,
- idx: codemap::Spanned<uint>) {
+ idx: codemap::Spanned<usize>) {
let tcx = fcx.ccx.tcx;
check_expr_with_lvalue_pref(fcx, base, lvalue_pref);
let expr_t = structurally_resolved_type(fcx, expr.span,
fcx.write_ty(id, typ);
}
ast::ExprBinary(op, ref lhs, ref rhs) => {
- check_binop(fcx, expr, op, &**lhs, rhs, SimpleBinop);
-
- let lhs_ty = fcx.expr_ty(&**lhs);
- let rhs_ty = fcx.expr_ty(&**rhs);
- if ty::type_is_error(lhs_ty) ||
- ty::type_is_error(rhs_ty) {
- fcx.write_error(id);
- }
+ op::check_binop(fcx, expr, op, lhs, rhs);
}
ast::ExprAssignOp(op, ref lhs, ref rhs) => {
- check_binop(fcx, expr, op, &**lhs, rhs, BinopAssignment);
-
- let lhs_t = fcx.expr_ty(&**lhs);
- let result_t = fcx.expr_ty(expr);
- demand::suptype(fcx, expr.span, result_t, lhs_t);
-
- let tcx = fcx.tcx();
- if !ty::expr_is_lval(tcx, &**lhs) {
- span_err!(tcx.sess, lhs.span, E0067, "illegal left-hand side expression");
- }
-
- fcx.require_expr_have_sized_type(&**lhs, traits::AssignmentLhsSized);
-
- // Overwrite result of check_binop...this preserves existing behavior
- // but seems quite dubious with regard to user-defined methods
- // and so forth. - Niko
- if !ty::type_is_error(result_t) {
- fcx.write_nil(expr.id);
- }
+ op::check_binop_assign(fcx, expr, op, lhs, rhs);
}
ast::ExprUnary(unop, ref oprnd) => {
let expected_inner = expected.to_option(fcx).map_or(NoExpectation, |ty| {
oprnd_t);
if !(ty::type_is_integral(oprnd_t) ||
oprnd_t.sty == ty::ty_bool) {
- oprnd_t = check_user_unop(fcx, "!", "not",
- tcx.lang_items.not_trait(),
- expr, &**oprnd, oprnd_t, unop);
+ oprnd_t = op::check_user_unop(fcx, "!", "not",
+ tcx.lang_items.not_trait(),
+ expr, &**oprnd, oprnd_t, unop);
}
}
ast::UnNeg => {
oprnd_t);
if !(ty::type_is_integral(oprnd_t) ||
ty::type_is_fp(oprnd_t)) {
- oprnd_t = check_user_unop(fcx, "-", "neg",
- tcx.lang_items.neg_trait(),
- expr, &**oprnd, oprnd_t, unop);
+ oprnd_t = op::check_user_unop(fcx, "-", "neg",
+ tcx.lang_items.neg_trait(),
+ expr, &**oprnd, oprnd_t, unop);
}
}
}
}
ast::ExprCast(ref e, ref t) => {
if let ast::TyFixedLengthVec(_, ref count_expr) = t.node {
- check_expr_with_hint(fcx, &**count_expr, tcx.types.uint);
+ check_expr_with_hint(fcx, &**count_expr, tcx.types.usize);
}
// Find the type of `e`. Supply hints based on the type we are casting to,
fcx.write_ty(id, typ);
}
ast::ExprRepeat(ref element, ref count_expr) => {
- check_expr_has_type(fcx, &**count_expr, tcx.types.uint);
+ check_expr_has_type(fcx, &**count_expr, tcx.types.usize);
let count = ty::eval_repeat_count(fcx.tcx(), &**count_expr);
let uty = match expected {
match result {
Some((index_ty, element_ty)) => {
- // FIXME: we've already checked idx above, we should
- // probably just demand subtype or something here.
- check_expr_has_type(fcx, &**idx, index_ty);
+ let idx_expr_ty = fcx.expr_ty(idx);
+ demand::eqtype(fcx, expr.span, index_ty, idx_expr_ty);
fcx.write_ty(id, element_ty);
}
_ => {
/// is useful in determining the concrete type.
///
/// The primary use case is where the expected type is a fat pointer,
- /// like `&[int]`. For example, consider the following statement:
+ /// like `&[isize]`. For example, consider the following statement:
///
- /// let x: &[int] = &[1, 2, 3];
+ /// let x: &[isize] = &[1, 2, 3];
///
/// In this case, the expected type for the `&[1, 2, 3]` expression is
- /// `&[int]`. If however we were to say that `[1, 2, 3]` has the
- /// expectation `ExpectHasType([int])`, that would be too strong --
- /// `[1, 2, 3]` does not have the type `[int]` but rather `[int; 3]`.
+ /// `&[isize]`. If however we were to say that `[1, 2, 3]` has the
+ /// expectation `ExpectHasType([isize])`, that would be too strong --
+ /// `[1, 2, 3]` does not have the type `[isize]` but rather `[isize; 3]`.
/// It is only the `&[1, 2, 3]` expression as a whole that can be coerced
- /// to the type `&[int]`. Therefore, we propagate this more limited hint,
+ /// to the type `&[isize]`. Therefore, we propagate this more limited hint,
/// which still is useful, because it informs integer literals and the like.
/// See the test case `test/run-pass/coerce-expect-unsized.rs` and #20169
/// for examples of where this comes up,.
ty: attr::IntType,
disr: ty::Disr) -> bool {
fn uint_in_range(ccx: &CrateCtxt, ty: ast::UintTy, disr: ty::Disr) -> bool {
- #![allow(trivial_numeric_casts)]
-
match ty {
ast::TyU8 => disr as u8 as Disr == disr,
ast::TyU16 => disr as u16 as Disr == disr,
ast::TyU32 => disr as u32 as Disr == disr,
ast::TyU64 => disr as u64 as Disr == disr,
- ast::TyUs(_) => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr)
+ ast::TyUs => uint_in_range(ccx, ccx.tcx.sess.target.uint_type, disr)
}
}
fn int_in_range(ccx: &CrateCtxt, ty: ast::IntTy, disr: ty::Disr) -> bool {
ast::TyI16 => disr as i16 as Disr == disr,
ast::TyI32 => disr as i32 as Disr == disr,
ast::TyI64 => disr as i64 as Disr == disr,
- ast::TyIs(_) => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr)
+ ast::TyIs => int_in_range(ccx, ccx.tcx.sess.target.int_type, disr)
}
}
match ty {
hint: attr::ReprAttr)
-> Vec<Rc<ty::VariantInfo<'tcx>>> {
#![allow(trivial_numeric_casts)]
- use std::num::Int;
let rty = ty::node_id_to_type(ccx.tcx, id);
let mut variants: Vec<Rc<ty::VariantInfo>> = Vec::new();
let inh = static_inherited_fields(ccx);
let fcx = blank_fn_ctxt(ccx, &inh, ty::FnConverging(rty), e.id);
let declty = match hint {
- attr::ReprAny | attr::ReprPacked | attr::ReprExtern => fcx.tcx().types.int,
+ attr::ReprAny | attr::ReprPacked |
+ attr::ReprExtern => fcx.tcx().types.isize,
+
attr::ReprInt(_, attr::SignedInt(ity)) => {
ty::mk_mach_int(fcx.tcx(), ity)
}
match t.sty {
ty::ty_param(ParamTy {idx, ..}) => {
debug!("Found use of ty param num {}", idx);
- tps_used[idx as uint] = true;
+ tps_used[idx as usize] = true;
}
_ => ()
}
let (n_tps, inputs, output) = match &name[..] {
"breakpoint" => (0, Vec::new(), ty::mk_nil(tcx)),
"size_of" |
- "pref_align_of" | "min_align_of" => (1, Vec::new(), ccx.tcx.types.uint),
- "init" => (1, Vec::new(), param(ccx, 0)),
+ "pref_align_of" | "min_align_of" => (1, Vec::new(), ccx.tcx.types.usize),
+ "init" | "init_dropped" => (1, Vec::new(), param(ccx, 0)),
"uninit" => (1, Vec::new(), param(ccx, 0)),
"forget" => (1, vec!( param(ccx, 0) ), ty::mk_nil(tcx)),
"transmute" => (2, vec!( param(ccx, 0) ), param(ccx, 1)),
ty: param(ccx, 0),
mutbl: ast::MutImmutable
}),
- ccx.tcx.types.int
+ ccx.tcx.types.isize
),
ty::mk_ptr(tcx, ty::mt {
ty: param(ccx, 0),
mutbl: ast::MutImmutable
}))
}
- "copy" | "copy_nonoverlapping" |
+ "copy" | "copy_nonoverlapping" => {
+ (1,
+ vec!(
+ ty::mk_ptr(tcx, ty::mt {
+ ty: param(ccx, 0),
+ mutbl: ast::MutImmutable
+ }),
+ ty::mk_ptr(tcx, ty::mt {
+ ty: param(ccx, 0),
+ mutbl: ast::MutMutable
+ }),
+ tcx.types.usize,
+ ),
+ ty::mk_nil(tcx))
+ }
"volatile_copy_memory" | "volatile_copy_nonoverlapping_memory" => {
(1,
vec!(
ty: param(ccx, 0),
mutbl: ast::MutImmutable
}),
- tcx.types.uint,
+ tcx.types.usize,
),
ty::mk_nil(tcx))
}
mutbl: ast::MutMutable
}),
tcx.types.u8,
- tcx.types.uint,
+ tcx.types.usize,
),
ty::mk_nil(tcx))
}
--- /dev/null
+// 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.
+
+//! Code related to processing overloaded binary and unary operators.
+
+use super::{
+ check_expr,
+ check_expr_coercable_to_type,
+ check_expr_with_lvalue_pref,
+ demand,
+ method,
+ FnCtxt,
+ PreferMutLvalue,
+ structurally_resolved_type,
+};
+use middle::infer;
+use middle::traits;
+use middle::ty::{self, Ty};
+use syntax::ast;
+use syntax::ast_util;
+use syntax::parse::token;
+use util::ppaux::{Repr, UserString};
+
+/// Check a `a <op>= b`
+pub fn check_binop_assign<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
+ expr: &'tcx ast::Expr,
+ op: ast::BinOp,
+ lhs_expr: &'tcx ast::Expr,
+ rhs_expr: &'tcx ast::Expr)
+{
+ let tcx = fcx.ccx.tcx;
+
+ check_expr_with_lvalue_pref(fcx, lhs_expr, PreferMutLvalue);
+ check_expr(fcx, rhs_expr);
+
+ let lhs_ty = structurally_resolved_type(fcx, lhs_expr.span, fcx.expr_ty(lhs_expr));
+ let rhs_ty = structurally_resolved_type(fcx, rhs_expr.span, fcx.expr_ty(rhs_expr));
+
+ if is_builtin_binop(fcx.tcx(), lhs_ty, rhs_ty, op) {
+ enforce_builtin_binop_types(fcx, lhs_expr, lhs_ty, rhs_expr, rhs_ty, op);
+ fcx.write_nil(expr.id);
+ } else {
+ // error types are considered "builtin"
+ assert!(!ty::type_is_error(lhs_ty) || !ty::type_is_error(rhs_ty));
+ span_err!(tcx.sess, lhs_expr.span, E0368,
+ "binary assignment operation `{}=` cannot be applied to types `{}` and `{}`",
+ ast_util::binop_to_string(op.node),
+ lhs_ty.user_string(fcx.tcx()),
+ rhs_ty.user_string(fcx.tcx()));
+ fcx.write_error(expr.id);
+ }
+
+ let tcx = fcx.tcx();
+ if !ty::expr_is_lval(tcx, lhs_expr) {
+ span_err!(tcx.sess, lhs_expr.span, E0067, "illegal left-hand side expression");
+ }
+
+ fcx.require_expr_have_sized_type(lhs_expr, traits::AssignmentLhsSized);
+}
+
+/// Check a potentially overloaded binary operator.
+pub fn check_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+ expr: &'tcx ast::Expr,
+ op: ast::BinOp,
+ lhs_expr: &'tcx ast::Expr,
+ rhs_expr: &'tcx ast::Expr)
+{
+ let tcx = fcx.ccx.tcx;
+
+ debug!("check_binop(expr.id={}, expr={}, op={:?}, lhs_expr={}, rhs_expr={})",
+ expr.id,
+ expr.repr(tcx),
+ op,
+ lhs_expr.repr(tcx),
+ rhs_expr.repr(tcx));
+
+ check_expr(fcx, lhs_expr);
+ let lhs_ty = fcx.resolve_type_vars_if_possible(fcx.expr_ty(lhs_expr));
+
+ // Annoyingly, SIMD ops don't fit into the PartialEq/PartialOrd
+ // traits, because their return type is not bool. Perhaps this
+ // should change, but for now if LHS is SIMD we go down a
+ // different path that bypassess all traits.
+ if ty::type_is_simd(fcx.tcx(), lhs_ty) {
+ check_expr_coercable_to_type(fcx, rhs_expr, lhs_ty);
+ let rhs_ty = fcx.resolve_type_vars_if_possible(fcx.expr_ty(lhs_expr));
+ let return_ty = enforce_builtin_binop_types(fcx, lhs_expr, lhs_ty, rhs_expr, rhs_ty, op);
+ fcx.write_ty(expr.id, return_ty);
+ return;
+ }
+
+ match BinOpCategory::from(op) {
+ BinOpCategory::Shortcircuit => {
+ // && and || are a simple case.
+ demand::suptype(fcx, lhs_expr.span, ty::mk_bool(tcx), lhs_ty);
+ check_expr_coercable_to_type(fcx, rhs_expr, ty::mk_bool(tcx));
+ fcx.write_ty(expr.id, ty::mk_bool(tcx));
+ }
+ _ => {
+ // Otherwise, we always treat operators as if they are
+ // overloaded. This is the way to be most flexible w/r/t
+ // types that get inferred.
+ let (rhs_ty, return_ty) =
+ check_overloaded_binop(fcx, expr, lhs_expr, lhs_ty, rhs_expr, op);
+
+ // Supply type inference hints if relevant. Probably these
+ // hints should be enforced during select as part of the
+ // `consider_unification_despite_ambiguity` routine, but this
+ // more convenient for now.
+ //
+ // The basic idea is to help type inference by taking
+ // advantage of things we know about how the impls for
+ // scalar types are arranged. This is important in a
+ // scenario like `1_u32 << 2`, because it lets us quickly
+ // deduce that the result type should be `u32`, even
+ // though we don't know yet what type 2 has and hence
+ // can't pin this down to a specific impl.
+ let rhs_ty = fcx.resolve_type_vars_if_possible(rhs_ty);
+ if
+ !ty::type_is_ty_var(lhs_ty) &&
+ !ty::type_is_ty_var(rhs_ty) &&
+ is_builtin_binop(fcx.tcx(), lhs_ty, rhs_ty, op)
+ {
+ let builtin_return_ty =
+ enforce_builtin_binop_types(fcx, lhs_expr, lhs_ty, rhs_expr, rhs_ty, op);
+ demand::suptype(fcx, expr.span, builtin_return_ty, return_ty);
+ }
+
+ fcx.write_ty(expr.id, return_ty);
+ }
+ }
+}
+
+fn enforce_builtin_binop_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+ lhs_expr: &'tcx ast::Expr,
+ lhs_ty: Ty<'tcx>,
+ rhs_expr: &'tcx ast::Expr,
+ rhs_ty: Ty<'tcx>,
+ op: ast::BinOp)
+ -> Ty<'tcx>
+{
+ debug_assert!(is_builtin_binop(fcx.tcx(), lhs_ty, rhs_ty, op));
+
+ let tcx = fcx.tcx();
+ match BinOpCategory::from(op) {
+ BinOpCategory::Shortcircuit => {
+ demand::suptype(fcx, lhs_expr.span, ty::mk_bool(tcx), lhs_ty);
+ demand::suptype(fcx, rhs_expr.span, ty::mk_bool(tcx), rhs_ty);
+ ty::mk_bool(tcx)
+ }
+
+ BinOpCategory::Shift => {
+ // For integers, the shift amount can be of any integral
+ // type. For simd, the type must match exactly.
+ if ty::type_is_simd(tcx, lhs_ty) {
+ demand::suptype(fcx, rhs_expr.span, lhs_ty, rhs_ty);
+ }
+
+ // result type is same as LHS always
+ lhs_ty
+ }
+
+ BinOpCategory::Math |
+ BinOpCategory::Bitwise => {
+ // both LHS and RHS and result will have the same type
+ demand::suptype(fcx, rhs_expr.span, lhs_ty, rhs_ty);
+ lhs_ty
+ }
+
+ BinOpCategory::Comparison => {
+ // both LHS and RHS and result will have the same type
+ demand::suptype(fcx, rhs_expr.span, lhs_ty, rhs_ty);
+
+ // if this is simd, result is same as lhs, else bool
+ if ty::type_is_simd(tcx, lhs_ty) {
+ let unit_ty = ty::simd_type(tcx, lhs_ty);
+ debug!("enforce_builtin_binop_types: lhs_ty={} unit_ty={}",
+ lhs_ty.repr(tcx),
+ unit_ty.repr(tcx));
+ if !ty::type_is_integral(unit_ty) {
+ tcx.sess.span_err(
+ lhs_expr.span,
+ &format!("binary comparison operation `{}` not supported \
+ for floating point SIMD vector `{}`",
+ ast_util::binop_to_string(op.node),
+ lhs_ty.user_string(tcx)));
+ tcx.types.err
+ } else {
+ lhs_ty
+ }
+ } else {
+ ty::mk_bool(tcx)
+ }
+ }
+ }
+}
+
+fn check_overloaded_binop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+ expr: &'tcx ast::Expr,
+ lhs_expr: &'tcx ast::Expr,
+ lhs_ty: Ty<'tcx>,
+ rhs_expr: &'tcx ast::Expr,
+ op: ast::BinOp)
+ -> (Ty<'tcx>, Ty<'tcx>)
+{
+ debug!("check_overloaded_binop(expr.id={}, lhs_ty={})",
+ expr.id,
+ lhs_ty.repr(fcx.tcx()));
+
+ let (name, trait_def_id) = name_and_trait_def_id(fcx, op);
+
+ // NB: As we have not yet type-checked the RHS, we don't have the
+ // type at hand. Make a variable to represent it. The whole reason
+ // for this indirection is so that, below, we can check the expr
+ // using this variable as the expected type, which sometimes lets
+ // us do better coercions than we would be able to do otherwise,
+ // particularly for things like `String + &String`.
+ let rhs_ty_var = fcx.infcx().next_ty_var();
+
+ let return_ty = match lookup_op_method(fcx, expr, lhs_ty, vec![rhs_ty_var],
+ token::intern(name), trait_def_id,
+ lhs_expr) {
+ Ok(return_ty) => return_ty,
+ Err(()) => {
+ // error types are considered "builtin"
+ if !ty::type_is_error(lhs_ty) {
+ span_err!(fcx.tcx().sess, lhs_expr.span, E0369,
+ "binary operation `{}` cannot be applied to type `{}`",
+ ast_util::binop_to_string(op.node),
+ lhs_ty.user_string(fcx.tcx()));
+ }
+ fcx.tcx().types.err
+ }
+ };
+
+ // see `NB` above
+ check_expr_coercable_to_type(fcx, rhs_expr, rhs_ty_var);
+
+ (rhs_ty_var, return_ty)
+}
+
+pub fn check_user_unop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
+ op_str: &str,
+ mname: &str,
+ trait_did: Option<ast::DefId>,
+ ex: &'tcx ast::Expr,
+ operand_expr: &'tcx ast::Expr,
+ operand_ty: Ty<'tcx>,
+ op: ast::UnOp)
+ -> Ty<'tcx>
+{
+ assert!(ast_util::is_by_value_unop(op));
+ match lookup_op_method(fcx, ex, operand_ty, vec![],
+ token::intern(mname), trait_did,
+ operand_expr) {
+ Ok(t) => t,
+ Err(()) => {
+ fcx.type_error_message(ex.span, |actual| {
+ format!("cannot apply unary operator `{}` to type `{}`",
+ op_str, actual)
+ }, operand_ty, None);
+ fcx.tcx().types.err
+ }
+ }
+}
+
+fn name_and_trait_def_id(fcx: &FnCtxt, op: ast::BinOp) -> (&'static str, Option<ast::DefId>) {
+ let lang = &fcx.tcx().lang_items;
+ match op.node {
+ ast::BiAdd => ("add", lang.add_trait()),
+ ast::BiSub => ("sub", lang.sub_trait()),
+ ast::BiMul => ("mul", lang.mul_trait()),
+ ast::BiDiv => ("div", lang.div_trait()),
+ ast::BiRem => ("rem", lang.rem_trait()),
+ ast::BiBitXor => ("bitxor", lang.bitxor_trait()),
+ ast::BiBitAnd => ("bitand", lang.bitand_trait()),
+ ast::BiBitOr => ("bitor", lang.bitor_trait()),
+ ast::BiShl => ("shl", lang.shl_trait()),
+ ast::BiShr => ("shr", lang.shr_trait()),
+ ast::BiLt => ("lt", lang.ord_trait()),
+ ast::BiLe => ("le", lang.ord_trait()),
+ ast::BiGe => ("ge", lang.ord_trait()),
+ ast::BiGt => ("gt", lang.ord_trait()),
+ ast::BiEq => ("eq", lang.eq_trait()),
+ ast::BiNe => ("ne", lang.eq_trait()),
+ ast::BiAnd | ast::BiOr => {
+ fcx.tcx().sess.span_bug(op.span, "&& and || are not overloadable")
+ }
+ }
+}
+
+fn lookup_op_method<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
+ expr: &'tcx ast::Expr,
+ lhs_ty: Ty<'tcx>,
+ other_tys: Vec<Ty<'tcx>>,
+ opname: ast::Name,
+ trait_did: Option<ast::DefId>,
+ lhs_expr: &'a ast::Expr)
+ -> Result<Ty<'tcx>,()>
+{
+ debug!("lookup_op_method(expr={}, lhs_ty={}, opname={:?}, trait_did={}, lhs_expr={})",
+ expr.repr(fcx.tcx()),
+ lhs_ty.repr(fcx.tcx()),
+ opname,
+ trait_did.repr(fcx.tcx()),
+ lhs_expr.repr(fcx.tcx()));
+
+ let method = match trait_did {
+ Some(trait_did) => {
+ // We do eager coercions to make using operators
+ // more ergonomic:
+ //
+ // - If the input is of type &'a T (resp. &'a mut T),
+ // then reborrow it to &'b T (resp. &'b mut T) where
+ // 'b <= 'a. This makes things like `x == y`, where
+ // `x` and `y` are both region pointers, work. We
+ // could also solve this with variance or different
+ // traits that don't force left and right to have same
+ // type.
+ let (adj_ty, adjustment) = match lhs_ty.sty {
+ ty::ty_rptr(r_in, mt) => {
+ let r_adj = fcx.infcx().next_region_var(infer::Autoref(lhs_expr.span));
+ fcx.mk_subr(infer::Reborrow(lhs_expr.span), r_adj, *r_in);
+ let adjusted_ty = ty::mk_rptr(fcx.tcx(), fcx.tcx().mk_region(r_adj), mt);
+ let autoptr = ty::AutoPtr(r_adj, mt.mutbl, None);
+ let adjustment = ty::AutoDerefRef { autoderefs: 1, autoref: Some(autoptr) };
+ (adjusted_ty, adjustment)
+ }
+ _ => {
+ (lhs_ty, ty::AutoDerefRef { autoderefs: 0, autoref: None })
+ }
+ };
+
+ debug!("adjusted_ty={} adjustment={:?}",
+ adj_ty.repr(fcx.tcx()),
+ adjustment);
+
+ method::lookup_in_trait_adjusted(fcx, expr.span, Some(lhs_expr), opname,
+ trait_did, adjustment, adj_ty, Some(other_tys))
+ }
+ None => None
+ };
+
+ match method {
+ Some(method) => {
+ let method_ty = method.ty;
+
+ // HACK(eddyb) Fully qualified path to work around a resolve bug.
+ let method_call = ::middle::ty::MethodCall::expr(expr.id);
+ fcx.inh.method_map.borrow_mut().insert(method_call, method);
+
+ // extract return type for method; all late bound regions
+ // should have been instantiated by now
+ let ret_ty = ty::ty_fn_ret(method_ty);
+ Ok(ty::no_late_bound_regions(fcx.tcx(), &ret_ty).unwrap().unwrap())
+ }
+ None => {
+ Err(())
+ }
+ }
+}
+
+// Binary operator categories. These categories summarize the behavior
+// with respect to the builtin operationrs supported.
+enum BinOpCategory {
+ /// &&, || -- cannot be overridden
+ Shortcircuit,
+
+ /// <<, >> -- when shifting a single integer, rhs can be any
+ /// integer type. For simd, types must match.
+ Shift,
+
+ /// +, -, etc -- takes equal types, produces same type as input,
+ /// applicable to ints/floats/simd
+ Math,
+
+ /// &, |, ^ -- takes equal types, produces same type as input,
+ /// applicable to ints/floats/simd/bool
+ Bitwise,
+
+ /// ==, !=, etc -- takes equal types, produces bools, except for simd,
+ /// which produce the input type
+ Comparison,
+}
+
+impl BinOpCategory {
+ fn from(op: ast::BinOp) -> BinOpCategory {
+ match op.node {
+ ast::BiShl | ast::BiShr =>
+ BinOpCategory::Shift,
+
+ ast::BiAdd |
+ ast::BiSub |
+ ast::BiMul |
+ ast::BiDiv |
+ ast::BiRem =>
+ BinOpCategory::Math,
+
+ ast::BiBitXor |
+ ast::BiBitAnd |
+ ast::BiBitOr =>
+ BinOpCategory::Bitwise,
+
+ ast::BiEq |
+ ast::BiNe |
+ ast::BiLt |
+ ast::BiLe |
+ ast::BiGe |
+ ast::BiGt =>
+ BinOpCategory::Comparison,
+
+ ast::BiAnd |
+ ast::BiOr =>
+ BinOpCategory::Shortcircuit,
+ }
+ }
+}
+
+/// Returns true if this is a built-in arithmetic operation (e.g. u32
+/// + u32, i16x4 == i16x4) and false if these types would have to be
+/// overloaded to be legal. There are two reasons that we distinguish
+/// builtin operations from overloaded ones (vs trying to drive
+/// everything uniformly through the trait system and intrinsics or
+/// something like that):
+///
+/// 1. Builtin operations can trivially be evaluated in constants.
+/// 2. For comparison operators applied to SIMD types the result is
+/// not of type `bool`. For example, `i16x4==i16x4` yields a
+/// type like `i16x4`. This means that the overloaded trait
+/// `PartialEq` is not applicable.
+///
+/// Reason #2 is the killer. I tried for a while to always use
+/// overloaded logic and just check the types in constants/trans after
+/// the fact, and it worked fine, except for SIMD types. -nmatsakis
+fn is_builtin_binop<'tcx>(cx: &ty::ctxt<'tcx>,
+ lhs: Ty<'tcx>,
+ rhs: Ty<'tcx>,
+ op: ast::BinOp)
+ -> bool
+{
+ match BinOpCategory::from(op) {
+ BinOpCategory::Shortcircuit => {
+ true
+ }
+
+ BinOpCategory::Shift => {
+ ty::type_is_error(lhs) || ty::type_is_error(rhs) ||
+ ty::type_is_integral(lhs) && ty::type_is_integral(rhs) ||
+ ty::type_is_simd(cx, lhs) && ty::type_is_simd(cx, rhs)
+ }
+
+ BinOpCategory::Math => {
+ ty::type_is_error(lhs) || ty::type_is_error(rhs) ||
+ ty::type_is_integral(lhs) && ty::type_is_integral(rhs) ||
+ ty::type_is_floating_point(lhs) && ty::type_is_floating_point(rhs) ||
+ ty::type_is_simd(cx, lhs) && ty::type_is_simd(cx, rhs)
+ }
+
+ BinOpCategory::Bitwise => {
+ ty::type_is_error(lhs) || ty::type_is_error(rhs) ||
+ ty::type_is_integral(lhs) && ty::type_is_integral(rhs) ||
+ ty::type_is_floating_point(lhs) && ty::type_is_floating_point(rhs) ||
+ ty::type_is_simd(cx, lhs) && ty::type_is_simd(cx, rhs) ||
+ ty::type_is_bool(lhs) && ty::type_is_bool(rhs)
+ }
+
+ BinOpCategory::Comparison => {
+ ty::type_is_error(lhs) || ty::type_is_error(rhs) ||
+ ty::type_is_scalar(lhs) && ty::type_is_scalar(rhs) ||
+ ty::type_is_simd(cx, lhs) && ty::type_is_simd(cx, rhs)
+ }
+ }
+}
+
/// This method populates the region map's `free_region_map`. It walks over the transformed
/// argument and return types for each function just before we check the body of that function,
/// looking for types where you have a borrowed pointer to other borrowed data (e.g., `&'a &'b
- /// [uint]`. We do not allow references to outlive the things they point at, so we can assume
+ /// [usize]`. We do not allow references to outlive the things they point at, so we can assume
/// that `'a <= 'b`. This holds for both the argument and return types, basically because, on
/// the caller side, the caller is responsible for checking that the type of every expression
/// (including the actual values for the arguments, as well as the return type of the fn call)
/// dereferenced, the lifetime of the pointer includes the deref expr.
fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
deref_expr: &ast::Expr,
- derefs: uint,
+ derefs: usize,
mut derefd_ty: Ty<'tcx>)
{
debug!("constrain_autoderefs(deref_expr={}, derefs={}, derefd_ty={})",
/// autoref'd.
fn link_autoref(rcx: &Rcx,
expr: &ast::Expr,
- autoderefs: uint,
+ autoderefs: usize,
autoref: &ty::AutoRef) {
debug!("link_autoref(autoref={:?})", autoref);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use check::{FnCtxt};
+use check::FnCtxt;
use middle::traits::{self, ObjectSafetyViolation, MethodViolationCode};
use middle::traits::{Obligation, ObligationCause};
use middle::traits::report_fulfillment_errors;
object_trait: &ty::TyTrait<'tcx>,
span: Span)
{
- let object_trait_ref =
- object_trait.principal_trait_ref_with_self_ty(tcx, tcx.types.err);
+ let trait_def_id = object_trait.principal_def_id();
- if traits::is_object_safe(tcx, object_trait_ref.clone()) {
+ if traits::is_object_safe(tcx, trait_def_id) {
return;
}
span_err!(tcx.sess, span, E0038,
"cannot convert to a trait object because trait `{}` is not object-safe",
- ty::item_path_str(tcx, object_trait_ref.def_id()));
+ ty::item_path_str(tcx, trait_def_id));
- let violations = traits::object_safety_violations(tcx, object_trait_ref.clone());
+ let violations = traits::object_safety_violations(tcx, trait_def_id);
for violation in violations {
match violation {
ObjectSafetyViolation::SizedSelf => {
use std::collections::HashSet;
use syntax::ast;
-use syntax::ast_util::{local_def};
-use syntax::attr;
+use syntax::ast_util::local_def;
use syntax::codemap::Span;
use syntax::parse::token::{self, special_idents};
use syntax::visit;
&fcx.inh.param_env.free_substs,
&trait_ref);
- // There are special rules that apply to drop.
- if
- fcx.tcx().lang_items.drop_trait() == Some(trait_ref.def_id) &&
- !attr::contains_name(&item.attrs, "unsafe_destructor")
- {
- match self_ty.sty {
- ty::ty_struct(def_id, _) |
- ty::ty_enum(def_id, _) => {
- check_struct_safe_for_destructor(fcx, item.span, def_id);
- }
- _ => {
- // Coherence already reports an error in this case.
- }
- }
- }
-
if fcx.tcx().lang_items.copy_trait() == Some(trait_ref.def_id) {
// This is checked in coherence.
return
// has left it as a NodeId rather than porting to CodeExtent.
scope: ast::NodeId,
- binding_count: uint,
+ binding_count: usize,
cache: Option<&'cx mut HashSet<Ty<'tcx>>>,
}
}
result
}
-
-///////////////////////////////////////////////////////////////////////////
-// Special drop trait checking
-
-fn check_struct_safe_for_destructor<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
- span: Span,
- struct_did: ast::DefId) {
- let struct_tpt = ty::lookup_item_type(fcx.tcx(), struct_did);
- if struct_tpt.generics.has_type_params(subst::TypeSpace)
- || struct_tpt.generics.has_region_params(subst::TypeSpace)
- {
- span_err!(fcx.tcx().sess, span, E0141,
- "cannot implement a destructor on a structure \
- with type parameters");
- span_note!(fcx.tcx().sess, span,
- "use \"#[unsafe_destructor]\" on the implementation \
- to force the compiler to allow this");
- }
-}
use std::cell::Cell;
use syntax::ast;
+use syntax::ast_util;
use syntax::codemap::{DUMMY_SP, Span};
use syntax::print::pprust::pat_to_string;
use syntax::visit;
return;
}
+ // Hacky hack: During type-checking, we treat *all* operators
+ // as potentially overloaded. But then, during writeback, if
+ // we observe that something like `a+b` is (known to be)
+ // operating on scalars, we clear the overload.
+ match e.node {
+ ast::ExprBinary(ref op, ref lhs, ref rhs) => {
+ let lhs_ty = self.fcx.expr_ty(lhs);
+ let lhs_ty = self.fcx.infcx().resolve_type_vars_if_possible(&lhs_ty);
+ let rhs_ty = self.fcx.expr_ty(rhs);
+ let rhs_ty = self.fcx.infcx().resolve_type_vars_if_possible(&rhs_ty);
+ if ty::type_is_scalar(lhs_ty) && ty::type_is_scalar(rhs_ty) {
+ self.fcx.inh.method_map.borrow_mut().remove(&MethodCall::expr(e.id));
+
+ // weird but true: the by-ref binops put an
+ // adjustment on the lhs but not the rhs; the
+ // adjustment for rhs is kind of baked into the
+ // system.
+ if !ast_util::is_by_value_binop(op.node) {
+ self.fcx.inh.adjustments.borrow_mut().remove(&lhs.id);
+ }
+ }
+ }
+ _ => { }
+ }
+
self.visit_node_id(ResolvingExpr(e.span), e.id);
self.visit_method_map_entry(ResolvingExpr(e.span),
MethodCall::expr(e.id));
match t.node {
ast::TyFixedLengthVec(ref ty, ref count_expr) => {
self.visit_ty(&**ty);
- write_ty_to_tcx(self.tcx(), count_expr.id, self.tcx().types.uint);
+ write_ty_to_tcx(self.tcx(), count_expr.id, self.tcx().types.usize);
}
_ => visit::walk_ty(self, t)
}
use middle::ty::{ty_rptr, ty_struct, ty_trait, ty_tup};
use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int};
use middle::ty::{ty_uint, ty_closure, ty_uniq, ty_bare_fn};
-use middle::ty::{ty_projection};
+use middle::ty::ty_projection;
use middle::ty;
use CrateCtxt;
use middle::infer::combine::Combine;
use middle::infer::InferCtxt;
-use middle::infer::{new_infer_ctxt};
-use std::collections::{HashSet};
+use middle::infer::new_infer_ctxt;
+use std::collections::HashSet;
use std::cell::RefCell;
use std::rc::Rc;
use syntax::ast::{Crate, DefId};
use syntax::ast;
use syntax::ast_map::NodeItem;
use syntax::ast_map;
-use syntax::ast_util::{local_def};
-use syntax::codemap::{Span};
+use syntax::ast_util::local_def;
+use syntax::codemap::Span;
use syntax::parse::token;
use syntax::visit;
use util::nodemap::{DefIdMap, FnvHashMap};
"i64",
item.span);
}
- ty::ty_int(ast::TyIs(_)) => {
+ ty::ty_int(ast::TyIs) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.isize_impl(),
"isize",
"u64",
item.span);
}
- ty::ty_uint(ast::TyUs(_)) => {
+ ty::ty_uint(ast::TyUs) => {
self.check_primitive_impl(def_id,
self.tcx.lang_items.usize_impl(),
"usize",
use middle::traits;
use middle::ty;
use middle::infer::{self, new_infer_ctxt};
-use syntax::ast::{DefId};
-use syntax::ast::{LOCAL_CRATE};
+use syntax::ast::DefId;
+use syntax::ast::LOCAL_CRATE;
use syntax::ast;
use syntax::ast_util;
use syntax::visit;
use syntax::ast_map;
use syntax::ast_util::local_def;
use syntax::codemap::Span;
-use syntax::parse::token::{special_idents};
+use syntax::parse::token::special_idents;
use syntax::parse::token;
use syntax::ptr::P;
use syntax::visit;
idx: index as u32,
name: ty_param.ident.name };
if !input_parameters.contains(¶m_ty) {
- if ty::has_attr(tcx, impl_def_id, "old_impl_check") {
- tcx.sess.span_warn(
- ty_param.span,
- &format!("the type parameter `{}` is not constrained by the \
- impl trait, self type, or predicates",
- param_ty.user_string(tcx)));
- } else {
- span_err!(tcx.sess, ty_param.span, E0207,
- "the type parameter `{}` is not constrained by the \
- impl trait, self type, or predicates",
- param_ty.user_string(tcx));
- }
+ span_err!(tcx.sess, ty_param.span, E0207,
+ "the type parameter `{}` is not constrained by the \
+ impl trait, self type, or predicates",
+ param_ty.user_string(tcx));
}
}
}
E0321, // extended coherence rules for defaulted traits violated
E0322, // cannot implement Sized explicitly
E0366, // dropck forbid specialization to concrete type or region
- E0367 // dropck forbid specialization to predicate not in struct/enum
+ E0367, // dropck forbid specialization to predicate not in struct/enum
+ E0368, // binary operation `<op>=` cannot be applied to types
+ E0369 // binary operation `<op>` cannot be applied to types
}
__build_diagnostic_array! { DIAGNOSTICS }
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
abi: abi::Rust,
sig: ty::Binder(ty::FnSig {
inputs: vec!(
- tcx.types.int,
+ tcx.types.isize,
ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, tcx.types.u8))
),
- output: ty::FnConverging(tcx.types.int),
+ output: ty::FnConverging(tcx.types.isize),
variadic: false,
}),
}));
pub trait RegionScope {
fn anon_regions(&self,
span: Span,
- count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>>;
+ count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>>;
/// If an object omits any explicit lifetime bound, and none can
/// be derived from the object traits, what should we use? If
fn anon_regions(&self,
_span: Span,
- _count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>> {
+ _count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>> {
Err(None)
}
}
// Same as `ExplicitRscope`, but provides some extra information for diagnostics
-pub struct UnelidableRscope(Vec<(String, uint)>);
+pub struct UnelidableRscope(Vec<(String, usize)>);
impl UnelidableRscope {
- pub fn new(v: Vec<(String, uint)>) -> UnelidableRscope {
+ pub fn new(v: Vec<(String, usize)>) -> UnelidableRscope {
UnelidableRscope(v)
}
}
fn anon_regions(&self,
_span: Span,
- _count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>> {
+ _count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>> {
let UnelidableRscope(ref v) = *self;
Err(Some(v.clone()))
}
fn anon_regions(&self,
_span: Span,
- count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>>
+ count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>>
{
Ok(repeat(self.default).take(count).collect())
}
fn anon_regions(&self,
_: Span,
- count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>>
+ count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>>
{
Ok((0..count).map(|_| self.next_region()).collect())
}
fn anon_regions(&self,
span: Span,
- count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>>
+ count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>>
{
self.base_scope.anon_regions(span, count)
}
fn anon_regions(&self,
span: Span,
- count: uint)
- -> Result<Vec<ty::Region>, Option<Vec<(String, uint)>>>
+ count: usize)
+ -> Result<Vec<ty::Region>, Option<Vec<(String, usize)>>>
{
match self.base_scope.anon_regions(span, count) {
Ok(mut v) => {
type VarianceTermPtr<'a> = &'a VarianceTerm<'a>;
#[derive(Copy, Debug)]
-struct InferredIndex(uint);
+struct InferredIndex(usize);
#[derive(Copy)]
enum VarianceTerm<'a> {
item_id: ast::NodeId,
kind: ParamKind,
space: ParamSpace,
- index: uint,
+ index: usize,
param_id: ast::NodeId,
term: VarianceTermPtr<'a>,
item_id: ast::NodeId,
kind: ParamKind,
space: ParamSpace,
- index: uint,
+ index: usize,
param_id: ast::NodeId) {
let inf_index = InferredIndex(self.inferred_infos.len());
let term = self.arena.alloc(InferredTerm(inf_index));
fn pick_initial_variance(&self,
item_id: ast::NodeId,
space: ParamSpace,
- index: uint)
+ index: usize)
-> ty::Variance
{
match space {
}
}
- fn num_inferred(&self) -> uint {
+ fn num_inferred(&self) -> usize {
self.inferred_infos.len()
}
}
item_def_id: ast::DefId,
kind: ParamKind,
space: ParamSpace,
- index: uint)
+ index: usize)
-> VarianceTermPtr<'a> {
assert_eq!(param_def_id.krate, item_def_id.krate);
}
ty::ty_param(ref data) => {
- let def_id = generics.types.get(data.space, data.idx as uint).def_id;
+ let def_id = generics.types.get(data.space, data.idx as usize).def_id;
assert_eq!(def_id.krate, ast::LOCAL_CRATE);
match self.terms_cx.inferred_map.get(&def_id.node) {
Some(&index) => {
for p in type_param_defs {
let variance_decl =
self.declared_variance(p.def_id, def_id, TypeParam,
- p.space, p.index as uint);
+ p.space, p.index as usize);
let variance_i = self.xform(variance, variance_decl);
- let substs_ty = *substs.types.get(p.space, p.index as uint);
+ let substs_ty = *substs.types.get(p.space, p.index as usize);
debug!("add_constraints_from_substs: variance_decl={:?} variance_i={:?}",
variance_decl, variance_i);
self.add_constraints_from_ty(generics, substs_ty, variance_i);
for p in region_param_defs {
let variance_decl =
self.declared_variance(p.def_id, def_id,
- RegionParam, p.space, p.index as uint);
+ RegionParam, p.space, p.index as usize);
let variance_i = self.xform(variance, variance_decl);
- let substs_r = *substs.regions().get(p.space, p.index as uint);
+ let substs_r = *substs.regions().get(p.space, p.index as usize);
self.add_constraints_from_region(generics, substs_r, variance_i);
}
}
}
ty::Predicate::Equate(ty::Binder(ref data)) => {
- self.add_constraints_from_ty(generics, data.0, variance);
- self.add_constraints_from_ty(generics, data.1, variance);
+ // A == B is only true if A and B are the same
+ // types, not subtypes of one another, so this is
+ // an invariant position:
+ self.add_constraints_from_ty(generics, data.0, self.invariant);
+ self.add_constraints_from_ty(generics, data.1, self.invariant);
}
ty::Predicate::TypeOutlives(ty::Binder(ref data)) => {
- self.add_constraints_from_ty(generics, data.0, variance);
+ // Why contravariant on both? Let's consider:
+ //
+ // Under what conditions is `(T:'t) <: (U:'u)`,
+ // meaning that `(T:'t) => (U:'u)`. The answer is
+ // if `U <: T` or `'u <= 't`. Let's see some examples:
+ //
+ // (T: 'big) => (T: 'small)
+ // where 'small <= 'big
+ //
+ // (&'small Foo: 't) => (&'big Foo: 't)
+ // where 'small <= 'big
+ // note that &'big Foo <: &'small Foo
let variance_r = self.xform(variance, self.contravariant);
+ self.add_constraints_from_ty(generics, data.0, variance_r);
self.add_constraints_from_region(generics, data.1, variance_r);
}
&*data.projection_ty.trait_ref,
variance);
+ // as the equality predicate above, a binder is a
+ // type equality relation, not a subtyping
+ // relation
self.add_constraints_from_ty(generics, data.ty, self.invariant);
}
}
/// For parameterized types, so the consumer of the JSON don't go
/// looking for types which don't exist anywhere.
Generic(String),
- /// Primitives are the fixed-size numeric types (plus int/uint/float), char,
+ /// Primitives are the fixed-size numeric types (plus int/usize/float), char,
/// arrays, slices, and tuples.
Primitive(PrimitiveType),
/// extern "ABI" fn
impl PrimitiveType {
fn from_str(s: &str) -> Option<PrimitiveType> {
match s {
- "isize" | "int" => Some(Isize),
+ "isize" => Some(Isize),
"i8" => Some(I8),
"i16" => Some(I16),
"i32" => Some(I32),
"i64" => Some(I64),
- "usize" | "uint" => Some(Usize),
+ "usize" => Some(Usize),
"u8" => Some(U8),
"u16" => Some(U16),
"u32" => Some(U32),
match self.sty {
ty::ty_bool => Primitive(Bool),
ty::ty_char => Primitive(Char),
- ty::ty_int(ast::TyIs(_)) => Primitive(Isize),
+ ty::ty_int(ast::TyIs) => Primitive(Isize),
ty::ty_int(ast::TyI8) => Primitive(I8),
ty::ty_int(ast::TyI16) => Primitive(I16),
ty::ty_int(ast::TyI32) => Primitive(I32),
ty::ty_int(ast::TyI64) => Primitive(I64),
- ty::ty_uint(ast::TyUs(_)) => Primitive(Usize),
+ ty::ty_uint(ast::TyUs) => Primitive(Usize),
ty::ty_uint(ast::TyU8) => Primitive(U8),
ty::ty_uint(ast::TyU16) => Primitive(U16),
ty::ty_uint(ast::TyU32) => Primitive(U32),
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct Span {
pub filename: String,
- pub loline: uint,
- pub locol: uint,
- pub hiline: uint,
- pub hicol: uint,
+ pub loline: usize,
+ pub locol: usize,
+ pub hiline: usize,
+ pub hicol: usize,
}
impl Span {
ast::TyStr => return Primitive(Str),
ast::TyBool => return Primitive(Bool),
ast::TyChar => return Primitive(Char),
- ast::TyInt(ast::TyIs(_)) => return Primitive(Isize),
+ ast::TyInt(ast::TyIs) => return Primitive(Isize),
ast::TyInt(ast::TyI8) => return Primitive(I8),
ast::TyInt(ast::TyI16) => return Primitive(I16),
ast::TyInt(ast::TyI32) => return Primitive(I32),
ast::TyInt(ast::TyI64) => return Primitive(I64),
- ast::TyUint(ast::TyUs(_)) => return Primitive(Usize),
+ ast::TyUint(ast::TyUs) => return Primitive(Usize),
ast::TyUint(ast::TyU8) => return Primitive(U8),
ast::TyUint(ast::TyU16) => return Primitive(U16),
ast::TyUint(ast::TyU32) => return Primitive(U32),
}
}
-thread_local!(static USED_HEADER_MAP: RefCell<HashMap<String, uint>> = {
+thread_local!(static USED_HEADER_MAP: RefCell<HashMap<String, usize>> = {
RefCell::new(HashMap::new())
});
});
let text = lines.collect::<Vec<&str>>().connect("\n");
tests.add_test(text.to_string(),
- block_info.should_fail, block_info.no_run,
+ block_info.should_panic, block_info.no_run,
block_info.ignore, block_info.test_harness);
}
}
#[derive(Eq, PartialEq, Clone, Debug)]
struct LangString {
- should_fail: bool,
+ should_panic: bool,
no_run: bool,
ignore: bool,
rust: bool,
impl LangString {
fn all_false() -> LangString {
LangString {
- should_fail: false,
+ should_panic: false,
no_run: false,
ignore: false,
rust: true, // NB This used to be `notrust = false`
for token in tokens {
match token {
"" => {},
- "should_fail" => { data.should_fail = true; seen_rust_tags = true; },
+ "should_panic" => { data.should_panic = true; seen_rust_tags = true; },
"no_run" => { data.no_run = true; seen_rust_tags = true; },
"ignore" => { data.ignore = true; seen_rust_tags = true; },
"rust" => { data.rust = true; seen_rust_tags = true; },
#[test]
fn test_lang_string_parse() {
fn t(s: &str,
- should_fail: bool, no_run: bool, ignore: bool, rust: bool, test_harness: bool) {
+ should_panic: bool, no_run: bool, ignore: bool, rust: bool, test_harness: bool) {
assert_eq!(LangString::parse(s), LangString {
- should_fail: should_fail,
+ should_panic: should_panic,
no_run: no_run,
ignore: ignore,
rust: rust,
})
}
- // marker | should_fail | no_run | ignore | rust | test_harness
+ // marker | should_panic| no_run | ignore | rust | test_harness
t("", false, false, false, true, false);
t("rust", false, false, false, true, false);
t("sh", false, false, false, false, false);
t("ignore", false, false, true, true, false);
- t("should_fail", true, false, false, true, false);
+ t("should_panic", true, false, false, true, false);
t("no_run", false, true, false, true, false);
t("test_harness", false, false, false, true, true);
t("{.no_run .example}", false, true, false, true, false);
- t("{.sh .should_fail}", true, false, false, true, false);
+ t("{.sh .should_panic}", true, false, false, true, false);
t("{.example .rust}", false, false, false, true, false);
t("{.test_harness .rust}", false, false, false, true, true);
}
pub trait_: clean::Type,
pub for_: clean::Type,
pub stability: Option<clean::Stability>,
+ pub polarity: Option<clean::ImplPolarity>,
}
/// Metadata about implementations for a type.
try!(write!(&mut w, ","));
}
try!(write!(&mut w, r#"[{},"{}","{}",{}"#,
- item.ty as uint, item.name, path,
+ item.ty as usize, item.name, path,
item.desc.to_json().to_string()));
match item.parent {
Some(nodeid) => {
try!(write!(&mut w, ","));
}
try!(write!(&mut w, r#"[{},"{}"]"#,
- short as uint, *fqp.last().unwrap()));
+ short as usize, *fqp.last().unwrap()));
}
try!(write!(&mut w, "]}};"));
// going on). If they're in different crates then the crate defining
// the trait will be interested in our implementation.
if imp.def_id.krate == did.krate { continue }
- try!(write!(&mut f, r#""{}impl{} {} for {}","#,
+ try!(write!(&mut f, r#""{}impl{} {}{} for {}","#,
ConciseStability(&imp.stability),
- imp.generics, imp.trait_, imp.for_));
+ imp.generics,
+ if imp.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
+ imp.trait_, imp.for_));
}
try!(writeln!(&mut f, r"];"));
try!(writeln!(&mut f, "{}", r"
trait_: i.trait_.as_ref().unwrap().clone(),
for_: i.for_.clone(),
stability: item.stability.clone(),
+ polarity: i.polarity.clone(),
});
}
Some(..) | None => {}
let mut indices = (0..items.len()).filter(|i| {
!cx.ignore_private_item(&items[*i])
- }).collect::<Vec<uint>>();
+ }).collect::<Vec<usize>>();
// the order of item types in the listing
fn reorder(ty: ItemType) -> u8 {
}
}
- fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> Ordering {
+ fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: usize, idx2: usize) -> Ordering {
let ty1 = shortty(i1);
let ty2 = shortty(i2);
if ty1 == ty2 {
.stability.Locked { border-color: #0084B6; color: #00668c; }
.stability.Unmarked { border-color: #BBBBBB; }
+td.summary-column {
+ width: 100%;
+}
+
.summary {
padding-right: 0px;
}
}
impl Toc {
- fn count_entries_with_level(&self, level: u32) -> uint {
+ fn count_entries_with_level(&self, level: u32) -> usize {
self.entries.iter().filter(|e| e.level == level).count()
}
}
#![crate_type = "dylib"]
#![crate_type = "rlib"]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
- html_favicon_url = "http://www.rust-lang.org/favicon.ico",
- html_root_url = "http://doc.rust-lang.org/nightly/",
- html_playground_url = "http://play.rust-lang.org/")]
+ html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+ html_root_url = "http://doc.rust-lang.org/nightly/",
+ html_playground_url = "http://play.rust-lang.org/")]
#![feature(box_patterns)]
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
#![feature(exit_status)]
-#![feature(int_uint)]
#![feature(set_stdio)]
#![feature(libc)]
-#![feature(old_path)]
#![feature(rustc_private)]
#![feature(staged_api)]
#![feature(std_misc)]
#![feature(path_ext)]
#![feature(path_relative_from)]
#![feature(convert)]
+#![feature(slice_patterns)]
extern crate arena;
extern crate getopts;
extern crate rustc_back;
extern crate serialize;
extern crate syntax;
-extern crate "test" as testing;
+extern crate test as testing;
extern crate unicode;
#[macro_use] extern crate log;
-extern crate "serialize" as rustc_serialize; // used by deriving
+extern crate serialize as rustc_serialize; // used by deriving
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::mpsc::channel;
-#[allow(deprecated)] use std::old_path::Path;
-
use externalfiles::ExternalHtml;
use serialize::Decodable;
use serialize::json::{self, Json};
&opts()));
}
-pub fn main_args(args: &[String]) -> int {
+pub fn main_args(args: &[String]) -> isize {
let matches = match getopts::getopts(args.tail(), &opts()) {
Ok(m) => m,
Err(err) => {
// Load all plugins/passes into a PluginManager
let path = matches.opt_str("plugin-path")
.unwrap_or("/tmp/rustdoc/plugins".to_string());
- let mut pm = plugins::PluginManager::new(Path::new(path));
+ let mut pm = plugins::PluginManager::new(PathBuf::from(path));
for pass in &passes {
let plugin = match PASSES.iter()
.position(|&(p, _, _)| {
/// Render `input` (e.g. "foo.md") into an HTML file in `output`
/// (e.g. output = "bar" => "bar/foo.html").
pub fn render(input: &str, mut output: PathBuf, matches: &getopts::Matches,
- external_html: &ExternalHtml, include_toc: bool) -> int {
+ external_html: &ExternalHtml, include_toc: bool) -> isize {
let input_p = Path::new(input);
output.push(input_p.file_stem().unwrap());
output.set_extension("html");
/// Run any tests/code examples in the markdown file `input`.
pub fn test(input: &str, libs: SearchPaths, externs: core::Externs,
- mut test_args: Vec<String>) -> int {
+ mut test_args: Vec<String>) -> isize {
let input_str = load_or_return!(input, 1, 2);
let mut collector = Collector::new(input.to_string(), libs, externs, true, false);
use serialize::json;
use std::mem;
use std::string::String;
-use std::old_path::{Path, GenericPath};
+use std::path::PathBuf;
pub type PluginJson = Option<(String, json::Json)>;
pub type PluginResult = (clean::Crate, PluginJson);
dylibs: Vec<dl::DynamicLibrary> ,
callbacks: Vec<PluginCallback> ,
/// The directory plugins will be loaded from
- pub prefix: Path,
+ pub prefix: PathBuf,
}
impl PluginManager {
/// Create a new plugin manager
- pub fn new(prefix: Path) -> PluginManager {
+ pub fn new(prefix: PathBuf) -> PluginManager {
PluginManager {
dylibs: Vec::new(),
callbacks: Vec::new(),
}
}
-// is the item considered publically visible?
+// is the item considered publicly visible?
fn visible(item: &Item) -> bool {
match item.inner {
ImplItem(_) => true,
externs: core::Externs,
mut test_args: Vec<String>,
crate_name: Option<String>)
- -> int {
+ -> isize {
let input_path = PathBuf::from(input);
let input = config::Input::File(input_path.clone());
// environment to ensure that the target loads the right libraries at
// runtime. It would be a sad day if the *host* libraries were loaded as a
// mistake.
- let mut cmd = Command::new(&outdir.path().join("rust-out"));
+ let mut cmd = Command::new(&outdir.path().join("rust_out"));
let var = DynamicLibrary::envvar();
let newpath = {
let path = env::var_os(var).unwrap_or(OsString::new());
if should_panic && out.status.success() {
panic!("test executable succeeded when it should have failed");
} else if !should_panic && !out.status.success() {
- panic!("test executable failed:\n{:?}",
- str::from_utf8(&out.stdout));
+ panic!("test executable failed:\n{}\n{}",
+ str::from_utf8(&out.stdout).unwrap_or(""),
+ str::from_utf8(&out.stderr).unwrap_or(""));
}
}
}
names: Vec<String>,
libs: SearchPaths,
externs: core::Externs,
- cnt: uint,
+ cnt: usize,
use_headers: bool,
current_header: Option<String>,
cratename: String,
fn to_hex(&self) -> String {
let mut v = Vec::with_capacity(self.len() * 2);
for &byte in self {
- v.push(CHARS[(byte >> 4) as uint]);
- v.push(CHARS[(byte & 0xf) as uint]);
+ v.push(CHARS[(byte >> 4) as usize]);
+ v.push(CHARS[(byte & 0xf) as usize]);
}
unsafe {
#[derive(Copy, Debug)]
pub enum FromHexError {
/// The input contained a character not part of the hex format
- InvalidHexCharacter(char, uint),
+ InvalidHexCharacter(char, usize),
/// The input had an invalid length
InvalidHexLength,
}
#[test]
pub fn test_to_hex_all_bytes() {
for i in 0..256 {
- assert_eq!([i as u8].to_hex(), format!("{:02x}", i as uint));
+ assert_eq!([i as u8].to_hex(), format!("{:02x}", i as usize));
}
}
pub fn test_from_hex_all_bytes() {
for i in 0..256 {
let ii: &[u8] = &[i as u8];
- assert_eq!(format!("{:02x}", i as uint).from_hex()
+ assert_eq!(format!("{:02x}", i as usize).from_hex()
.unwrap(),
ii);
- assert_eq!(format!("{:02X}", i as uint).from_hex()
+ assert_eq!(format!("{:02X}", i as usize).from_hex()
.unwrap(),
ii);
}
use std::collections::{HashMap, BTreeMap};
use std::io::prelude::*;
use std::io;
-use std::mem::{swap};
+use std::mem::swap;
use std::num::FpCategory as Fp;
+#[allow(deprecated)]
+use std::num::wrapping::WrappingOps;
use std::ops::Index;
use std::str::FromStr;
use std::string;
pub struct PrettyJson<'a> { inner: &'a Json }
pub struct AsJson<'a, T: 'a> { inner: &'a T }
-pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<uint> }
+pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<usize> }
/// The errors that can arise while parsing a JSON stream.
#[derive(Clone, Copy, PartialEq, Debug)]
#[derive(Clone, PartialEq, Debug)]
pub enum ParserError {
/// msg, line, col
- SyntaxError(ErrorCode, uint, uint),
+ SyntaxError(ErrorCode, usize, usize),
IoError(io::ErrorKind, String),
}
escape_str(writer, buf)
}
-fn spaces(wr: &mut fmt::Write, mut n: uint) -> EncodeResult {
+fn spaces(wr: &mut fmt::Write, mut n: usize) -> EncodeResult {
const BUF: &'static str = " ";
while n >= BUF.len() {
Ok(())
}
- fn emit_uint(&mut self, v: uint) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+ fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
- fn emit_int(&mut self, v: int) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+ fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_enum_variant<F>(&mut self,
name: &str,
- _id: uint,
- cnt: uint,
+ _id: usize,
+ cnt: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
}
}
- fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
fn emit_enum_struct_variant<F>(&mut self,
name: &str,
- id: uint,
- cnt: uint,
+ id: usize,
+ cnt: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str,
- idx: uint,
+ idx: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
self.emit_enum_variant_arg(idx, f)
}
- fn emit_struct<F>(&mut self, _: &str, _: uint, f: F) -> EncodeResult where
+ fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
+ fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq(len, f)
}
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq_elt(idx, f)
}
- fn emit_tuple_struct<F>(&mut self, _name: &str, len: uint, f: F) -> EncodeResult where
+ fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq(len, f)
}
- fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
- fn emit_seq<F>(&mut self, _len: uint, f: F) -> EncodeResult where
+ fn emit_seq<F>(&mut self, _len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
- fn emit_map<F>(&mut self, _len: uint, f: F) -> EncodeResult where
+ fn emit_map<F>(&mut self, _len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
/// compact data
pub struct PrettyEncoder<'a> {
writer: &'a mut (fmt::Write+'a),
- curr_indent: uint,
- indent: uint,
+ curr_indent: usize,
+ indent: usize,
is_emitting_map_key: bool,
}
/// Set the number of spaces to indent for each level.
/// This is safe to set during encoding.
- pub fn set_indent(&mut self, indent: uint) {
+ pub fn set_indent(&mut self, indent: usize) {
// self.indent very well could be 0 so we need to use checked division.
let level = self.curr_indent.checked_div(self.indent).unwrap_or(0);
self.indent = indent;
Ok(())
}
- fn emit_uint(&mut self, v: uint) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+ fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
- fn emit_int(&mut self, v: int) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+ fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
fn emit_enum_variant<F>(&mut self,
name: &str,
- _id: uint,
- cnt: uint,
+ _id: usize,
+ cnt: usize,
f: F)
-> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
}
}
- fn emit_enum_variant_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
fn emit_enum_struct_variant<F>(&mut self,
name: &str,
- id: uint,
- cnt: uint,
+ id: usize,
+ cnt: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str,
- idx: uint,
+ idx: usize,
f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
}
- fn emit_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
+ fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_struct_field<F>(&mut self, name: &str, idx: uint, f: F) -> EncodeResult where
+ fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq(len, f)
}
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq_elt(idx, f)
}
- fn emit_tuple_struct<F>(&mut self, _: &str, len: uint, f: F) -> EncodeResult where
+ fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq(len, f)
}
- fn emit_tuple_struct_arg<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
- fn emit_seq<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
- fn emit_map<F>(&mut self, len: uint, f: F) -> EncodeResult where
+ fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> EncodeResult where
+ fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
Ok(())
}
- fn emit_map_elt_val<F>(&mut self, _idx: uint, f: F) -> EncodeResult where
+ fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
}
}
-#[cfg(stage0)]
-impl<'a> Index<&'a str> for Json {
- type Output = Json;
-
- fn index(&self, idx: & &str) -> &Json {
- self.find(*idx).unwrap()
- }
-}
-
-#[cfg(not(stage0))]
impl<'a> Index<&'a str> for Json {
type Output = Json;
}
}
-#[cfg(stage0)]
-impl Index<uint> for Json {
- type Output = Json;
-
- fn index<'a>(&'a self, idx: &uint) -> &'a Json {
- match self {
- &Json::Array(ref v) => &v[*idx],
- _ => panic!("can only index Json with uint if it is an array")
- }
- }
-}
-
-#[cfg(not(stage0))]
-impl Index<uint> for Json {
+impl Index<usize> for Json {
type Output = Json;
- fn index<'a>(&'a self, idx: uint) -> &'a Json {
+ fn index<'a>(&'a self, idx: usize) -> &'a Json {
match self {
&Json::Array(ref v) => &v[idx],
- _ => panic!("can only index Json with uint if it is an array")
+ _ => panic!("can only index Json with usize if it is an array")
}
}
}
}
/// Returns The number of elements in the Stack.
- pub fn len(&self) -> uint { self.stack.len() }
+ pub fn len(&self) -> usize { self.stack.len() }
/// Returns true if the stack is empty.
pub fn is_empty(&self) -> bool { self.stack.is_empty() }
/// Provides access to the StackElement at a given index.
/// lower indices are at the bottom of the stack while higher indices are
/// at the top.
- pub fn get<'l>(&'l self, idx: uint) -> StackElement<'l> {
+ pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
match self.stack[idx] {
InternalIndex(i) => StackElement::Index(i),
InternalKey(start, size) => {
StackElement::Key(str::from_utf8(
- &self.str_buffer[start as uint .. start as uint + size as uint])
+ &self.str_buffer[start as usize .. start as usize + size as usize])
.unwrap())
}
}
Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
Some(&InternalKey(start, size)) => {
Some(StackElement::Key(str::from_utf8(
- &self.str_buffer[start as uint .. (start+size) as uint]
+ &self.str_buffer[start as usize .. (start+size) as usize]
).unwrap()))
}
}
assert!(!self.is_empty());
match *self.stack.last().unwrap() {
InternalKey(_, sz) => {
- let new_size = self.str_buffer.len() - sz as uint;
+ let new_size = self.str_buffer.len() - sz as usize;
self.str_buffer.truncate(new_size);
}
InternalIndex(_) => {}
pub struct Parser<T> {
rdr: T,
ch: Option<char>,
- line: uint,
- col: uint,
+ line: usize,
+ col: usize,
// We maintain a stack representing where we are in the logical structure
// of the JSON stream.
stack: Stack,
}
}
+ #[allow(deprecated)] // possible resolve bug is mapping these to traits
fn parse_u64(&mut self) -> Result<u64, ParserError> {
let mut accum = 0;
let last_accum = 0; // necessary to detect overflow.
match self.ch_or_null() {
c @ '0' ... '9' => {
dec /= 10.0;
- res += (((c as int) - ('0' as int)) as f64) * dec;
+ res += (((c as isize) - ('0' as isize)) as f64) * dec;
self.bump();
}
_ => break,
match self.ch_or_null() {
c @ '0' ... '9' => {
exp *= 10;
- exp += (c as uint) - ('0' as uint);
+ exp += (c as usize) - ('0' as usize);
self.bump();
}
// information to return a JsonEvent.
// Manages an internal state so that parsing can be interrupted and resumed.
// Also keeps track of the position in the logical structure of the json
- // stream int the form of a stack that can be queried by the user using the
+ // stream isize the form of a stack that can be queried by the user using the
// stack() method.
fn parse(&mut self) -> JsonEvent {
loop {
None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
},
Json::F64(f) => Err(ExpectedError("Integer".to_string(), format!("{}", f))),
- // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
+ // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
// is going to have a string here, as per JSON spec.
Json::String(s) => match s.parse().ok() {
Some(f) => Ok(f),
expect!(self.pop(), Null)
}
- read_primitive! { read_uint, uint }
+ read_primitive! { read_uint, usize }
read_primitive! { read_u8, u8 }
read_primitive! { read_u16, u16 }
read_primitive! { read_u32, u32 }
read_primitive! { read_u64, u64 }
- read_primitive! { read_int, int }
+ read_primitive! { read_int, isize }
read_primitive! { read_i8, i8 }
read_primitive! { read_i16, i16 }
read_primitive! { read_i32, i32 }
Json::U64(f) => Ok(f as f64),
Json::F64(f) => Ok(f),
Json::String(s) => {
- // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
+ // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
// is going to have a string here, as per JSON spec.
match s.parse().ok() {
Some(f) => Ok(f),
fn read_enum_variant<T, F>(&mut self, names: &[&str],
mut f: F) -> DecodeResult<T>
- where F: FnMut(&mut Decoder, uint) -> DecodeResult<T>,
+ where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
{
let name = match self.pop() {
Json::String(s) => s,
f(self, idx)
}
- fn read_enum_variant_arg<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
+ fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
- F: FnMut(&mut Decoder, uint) -> DecodeResult<T>,
+ F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
{
self.read_enum_variant(names, f)
}
fn read_enum_struct_variant_field<T, F>(&mut self,
_name: &str,
- idx: uint,
+ idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
self.read_enum_variant_arg(idx, f)
}
- fn read_struct<T, F>(&mut self, _name: &str, _len: uint, f: F) -> DecodeResult<T> where
+ fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
let value = try!(f(self));
fn read_struct_field<T, F>(&mut self,
name: &str,
- _idx: uint,
+ _idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
Ok(value)
}
- fn read_tuple<T, F>(&mut self, tuple_len: uint, f: F) -> DecodeResult<T> where
+ fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_seq(move |d, len| {
})
}
- fn read_tuple_arg<T, F>(&mut self, idx: uint, f: F) -> DecodeResult<T> where
+ fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_seq_elt(idx, f)
fn read_tuple_struct<T, F>(&mut self,
_name: &str,
- len: uint,
+ len: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
}
fn read_tuple_struct_arg<T, F>(&mut self,
- idx: uint,
+ idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
}
fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
+ F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
{
let array = try!(expect!(self.pop(), Array));
let len = array.len();
f(self, len)
}
- fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
+ fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
- F: FnOnce(&mut Decoder, uint) -> DecodeResult<T>,
+ F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
{
let obj = try!(expect!(self.pop(), Object));
let len = obj.len();
f(self, len)
}
- fn read_map_elt_key<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
+ fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
- fn read_map_elt_val<T, F>(&mut self, _idx: uint, f: F) -> DecodeResult<T> where
+ fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
($($t:ty), +) => (
$(impl ToJson for $t {
fn to_json(&self) -> Json {
- #![allow(trivial_numeric_casts)]
Json::I64(*self as i64)
}
})+
)
}
-to_json_impl_i64! { int, i8, i16, i32, i64 }
+to_json_impl_i64! { isize, i8, i16, i32, i64 }
macro_rules! to_json_impl_u64 {
($($t:ty), +) => (
$(impl ToJson for $t {
fn to_json(&self) -> Json {
- #![allow(trivial_numeric_casts)]
Json::U64(*self as u64)
}
})+
)
}
-to_json_impl_u64! { uint, u8, u16, u32, u64 }
+to_json_impl_u64! { usize, u8, u16, u32, u64 }
impl ToJson for Json {
fn to_json(&self) -> Json { self.clone() }
impl<'a, T> AsPrettyJson<'a, T> {
/// Set the indentation level for the emitted JSON
- pub fn indent(mut self, indent: uint) -> AsPrettyJson<'a, T> {
+ pub fn indent(mut self, indent: usize) -> AsPrettyJson<'a, T> {
self.indent = Some(indent);
self
}
#[derive(RustcDecodable, Eq, PartialEq, Debug)]
struct OptionData {
- opt: Option<uint>,
+ opt: Option<usize>,
}
#[test]
#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
enum Animal {
Dog,
- Frog(string::String, int)
+ Frog(string::String, isize)
}
#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
struct Inner {
a: (),
- b: uint,
+ b: usize,
c: Vec<string::String>,
}
let v: Vec<bool> = super::decode("[true]").unwrap();
assert_eq!(v, [true]);
- let v: Vec<int> = super::decode("[3, 1]").unwrap();
+ let v: Vec<isize> = super::decode("[3, 1]").unwrap();
assert_eq!(v, [3, 1]);
- let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").unwrap();
+ let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
assert_eq!(v, [vec![3], vec![1, 2]]);
}
#[test]
fn test_decode_tuple() {
- let t: (uint, uint, uint) = super::decode("[1, 2, 3]").unwrap();
+ let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
assert_eq!(t, (1, 2, 3));
- let t: (uint, string::String) = super::decode("[1, \"two\"]").unwrap();
+ let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
assert_eq!(t, (1, "two".to_string()));
}
#[test]
fn test_decode_tuple_malformed_types() {
- assert!(super::decode::<(uint, string::String)>("[1, 2]").is_err());
+ assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
}
#[test]
fn test_decode_tuple_malformed_length() {
- assert!(super::decode::<(uint, uint)>("[1, 2, 3]").is_err());
+ assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
}
#[test]
use std::str::from_utf8;
use std::old_io::Writer;
use std::collections::HashMap;
- let mut hm: HashMap<uint, bool> = HashMap::new();
+ let mut hm: HashMap<usize, bool> = HashMap::new();
hm.insert(1, true);
let mut mem_buf = Vec::new();
write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
use std::str::from_utf8;
use std::old_io::Writer;
use std::collections::HashMap;
- let mut hm: HashMap<uint, bool> = HashMap::new();
+ let mut hm: HashMap<usize, bool> = HashMap::new();
hm.insert(1, true);
let mut mem_buf = Vec::new();
write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
);
// Helper function for counting indents
- fn indents(source: &str) -> uint {
+ fn indents(source: &str) -> usize {
let trimmed = source.trim_left_matches(' ');
source.len() - trimmed.len()
}
Ok(o) => o
};
let mut decoder = Decoder::new(json_obj);
- let _hm: HashMap<uint, bool> = Decodable::decode(&mut decoder).unwrap();
+ let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
}
#[test]
Ok(o) => o
};
let mut decoder = Decoder::new(json_obj);
- let result: Result<HashMap<uint, bool>, DecoderError> = Decodable::decode(&mut decoder);
+ let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
}
assert_eq!(hash_map.to_json(), object);
assert_eq!(Some(15).to_json(), I64(15));
assert_eq!(Some(15 as usize).to_json(), U64(15));
- assert_eq!(None::<int>.to_json(), Null);
+ assert_eq!(None::<isize>.to_json(), Null);
}
#[test]
fn test_encode_hashmap_with_arbitrary_key() {
use std::collections::HashMap;
#[derive(PartialEq, Eq, Hash, RustcEncodable)]
- struct ArbitraryType(uint);
+ struct ArbitraryType(usize);
let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
hm.insert(ArbitraryType(1), true);
let mut mem_buf = string::String::new();
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(old_path)]
#![feature(rustc_private)]
#![feature(staged_api)]
// Primitive types:
fn emit_nil(&mut self) -> Result<(), Self::Error>;
- fn emit_uint(&mut self, v: uint) -> Result<(), Self::Error>;
+ fn emit_uint(&mut self, v: usize) -> Result<(), Self::Error>;
fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
- fn emit_int(&mut self, v: int) -> Result<(), Self::Error>;
+ fn emit_int(&mut self, v: isize) -> Result<(), Self::Error>;
fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_variant<F>(&mut self, v_name: &str,
- v_id: uint,
- len: uint,
+ v_id: usize,
+ len: usize,
f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_enum_variant_arg<F>(&mut self, a_idx: uint, f: F)
+ fn emit_enum_variant_arg<F>(&mut self, a_idx: usize, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
- v_id: uint,
- len: uint,
+ v_id: usize,
+ len: usize,
f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_enum_struct_variant_field<F>(&mut self,
f_name: &str,
- f_idx: uint,
+ f_idx: usize,
f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_struct<F>(&mut self, name: &str, len: uint, f: F)
+ fn emit_struct<F>(&mut self, name: &str, len: usize, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: uint, f: F)
+ fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: usize, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_tuple<F>(&mut self, len: uint, f: F) -> Result<(), Self::Error>
+ fn emit_tuple<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_tuple_arg<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
+ fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_tuple_struct<F>(&mut self, name: &str, len: uint, f: F)
+ fn emit_tuple_struct<F>(&mut self, name: &str, len: usize, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_tuple_struct_arg<F>(&mut self, f_idx: uint, f: F)
+ fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F)
-> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_seq<F>(&mut self, len: uint, f: F) -> Result<(), Self::Error>
+ fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_seq_elt<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
+ fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_map<F>(&mut self, len: uint, f: F) -> Result<(), Self::Error>
+ fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_map_elt_key<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
+ fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
- fn emit_map_elt_val<F>(&mut self, idx: uint, f: F) -> Result<(), Self::Error>
+ fn emit_map_elt_val<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
}
// Primitive types:
fn read_nil(&mut self) -> Result<(), Self::Error>;
- fn read_uint(&mut self) -> Result<uint, Self::Error>;
+ fn read_uint(&mut self) -> Result<usize, Self::Error>;
fn read_u64(&mut self) -> Result<u64, Self::Error>;
fn read_u32(&mut self) -> Result<u32, Self::Error>;
fn read_u16(&mut self) -> Result<u16, Self::Error>;
fn read_u8(&mut self) -> Result<u8, Self::Error>;
- fn read_int(&mut self) -> Result<int, Self::Error>;
+ fn read_int(&mut self) -> Result<isize, Self::Error>;
fn read_i64(&mut self) -> Result<i64, Self::Error>;
fn read_i32(&mut self) -> Result<i32, Self::Error>;
fn read_i16(&mut self) -> Result<i16, Self::Error>;
fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
-> Result<T, Self::Error>
- where F: FnMut(&mut Self, uint) -> Result<T, Self::Error>;
- fn read_enum_variant_arg<T, F>(&mut self, a_idx: uint, f: F)
+ where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
+ fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
-> Result<T, Self::Error>
- where F: FnMut(&mut Self, uint) -> Result<T, Self::Error>;
+ where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
fn read_enum_struct_variant_field<T, F>(&mut self,
&f_name: &str,
- f_idx: uint,
+ f_idx: usize,
f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
- fn read_struct<T, F>(&mut self, s_name: &str, len: uint, f: F)
+ fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_struct_field<T, F>(&mut self,
f_name: &str,
- f_idx: uint,
+ f_idx: usize,
f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
- fn read_tuple<T, F>(&mut self, len: uint, f: F) -> Result<T, Self::Error>
+ fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
- fn read_tuple_arg<T, F>(&mut self, a_idx: uint, f: F)
+ fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
- fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: uint, f: F)
+ fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
- fn read_tuple_struct_arg<T, F>(&mut self, a_idx: uint, f: F)
+ fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
where F: FnMut(&mut Self, bool) -> Result<T, Self::Error>;
fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self, uint) -> Result<T, Self::Error>;
- fn read_seq_elt<T, F>(&mut self, idx: uint, f: F) -> Result<T, Self::Error>
+ where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
+ fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
- where F: FnOnce(&mut Self, uint) -> Result<T, Self::Error>;
- fn read_map_elt_key<T, F>(&mut self, idx: uint, f: F)
+ where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
+ fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
- fn read_map_elt_val<T, F>(&mut self, idx: uint, f: F)
+ fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
-> Result<T, Self::Error>
where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>;
}
-impl Encodable for uint {
+impl Encodable for usize {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_uint(*self)
}
}
-impl Decodable for uint {
- fn decode<D: Decoder>(d: &mut D) -> Result<uint, D::Error> {
+impl Decodable for usize {
+ fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error> {
d.read_uint()
}
}
}
}
-impl Encodable for int {
+impl Encodable for isize {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
s.emit_int(*self)
}
}
-impl Decodable for int {
- fn decode<D: Decoder>(d: &mut D) -> Result<int, D::Error> {
+impl Decodable for isize {
+ fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error> {
d.read_int()
}
}
impl<$($name:Decodable),*> Decodable for ($($name,)*) {
#[allow(non_snake_case)]
fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
- let len: uint = count_idents!($($name,)*);
+ let len: usize = count_idents!($($name,)*);
d.read_tuple(len, |d| {
let mut i = 0;
let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },
fn into_ascii_lowercase(self) -> Self;
}
-/// Extension methods for ASCII-subset only operations on string slices
+/// Extension methods for ASCII-subset only operations on string slices.
#[stable(feature = "rust1", since = "1.0.0")]
pub trait AsciiExt {
/// Container type for copied ASCII characters.
type Owned;
/// Check if within the ASCII range.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ascii::AsciiExt;
+ ///
+ /// let ascii = 'a';
+ /// let utf8 = '❤';
+ ///
+ /// assert_eq!(true, ascii.is_ascii());
+ /// assert_eq!(false, utf8.is_ascii())
+ /// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn is_ascii(&self) -> bool;
- /// Makes a copy of the string in ASCII upper case:
+ /// Makes a copy of the string in ASCII upper case.
+ ///
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ascii::AsciiExt;
+ ///
+ /// let ascii = 'a';
+ /// let utf8 = '❤';
+ ///
+ /// assert_eq!('A', ascii.to_ascii_uppercase());
+ /// assert_eq!('❤', utf8.to_ascii_uppercase());
+ /// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn to_ascii_uppercase(&self) -> Self::Owned;
- /// Makes a copy of the string in ASCII lower case:
+ /// Makes a copy of the string in ASCII lower case.
+ ///
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ascii::AsciiExt;
+ ///
+ /// let ascii = 'A';
+ /// let utf8 = '❤';
+ ///
+ /// assert_eq!('a', ascii.to_ascii_lowercase());
+ /// assert_eq!('❤', utf8.to_ascii_lowercase());
+ /// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn to_ascii_lowercase(&self) -> Self::Owned;
/// Check that two strings are an ASCII case-insensitive match.
+ ///
/// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
/// but without allocating and copying temporary strings.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ascii::AsciiExt;
+ ///
+ /// let ascii1 = 'A';
+ /// let ascii2 = 'a';
+ /// let ascii3 = 'A';
+ /// let ascii4 = 'z';
+ ///
+ /// assert_eq!(true, ascii1.eq_ignore_ascii_case(&ascii2));
+ /// assert_eq!(true, ascii1.eq_ignore_ascii_case(&ascii3));
+ /// assert_eq!(false, ascii1.eq_ignore_ascii_case(&ascii4));
+ /// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn eq_ignore_ascii_case(&self, other: &Self) -> bool;
/// Convert this type to its ASCII upper case equivalent in-place.
///
/// See `to_ascii_uppercase` for more information.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #![feature(ascii)]
+ /// use std::ascii::AsciiExt;
+ ///
+ /// let mut ascii = 'a';
+ ///
+ /// ascii.make_ascii_uppercase();
+ ///
+ /// assert_eq!('A', ascii);
+ /// ```
#[unstable(feature = "ascii")]
fn make_ascii_uppercase(&mut self);
/// Convert this type to its ASCII lower case equivalent in-place.
///
/// See `to_ascii_lowercase` for more information.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #![feature(ascii)]
+ /// use std::ascii::AsciiExt;
+ ///
+ /// let mut ascii = 'A';
+ ///
+ /// ascii.make_ascii_lowercase();
+ ///
+ /// assert_eq!('a', ascii);
+ /// ```
#[unstable(feature = "ascii")]
fn make_ascii_lowercase(&mut self);
}
data: [u8; 4],
}
-/// Returns a 'default' ASCII and C++11-like literal escape of a `u8`
+/// Returns an iterator that produces an escaped version of a `u8`.
///
/// The default is chosen with a bias toward producing literals that are
/// legal in a variety of languages, including C++11 and similar C-family
/// - Any other chars in the range [0x20,0x7e] are not escaped.
/// - Any other chars are given hex escapes of the form '\xNN'.
/// - Unicode escapes are never generated by this function.
+///
+/// # Examples
+///
+/// ```
+/// use std::ascii;
+///
+/// let escaped = ascii::escape_default(b'0').next().unwrap();
+/// assert_eq!(b'0', escaped);
+///
+/// let mut escaped = ascii::escape_default(b'\t');
+///
+/// assert_eq!(b'\\', escaped.next().unwrap());
+/// assert_eq!(b't', escaped.next().unwrap());
+/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn escape_default(c: u8) -> EscapeDefault {
let (data, len) = match c {
use prelude::v1::*;
use self::test::Bencher;
-use iter::{range_inclusive};
+use iter::range_inclusive;
#[bench]
fn new_drop(b : &mut Bencher) {
use default::Default;
use fmt::{self, Debug};
use hash::{Hash, SipHasher};
-use iter::{self, Iterator, ExactSizeIterator, IntoIterator, IteratorExt, FromIterator, Extend, Map};
+use iter::{self, Iterator, ExactSizeIterator, IntoIterator, FromIterator, Extend, Map};
use marker::Sized;
use mem::{self, replace};
use ops::{Deref, FnMut, FnOnce, Index};
/// overridden with one of the constructors.
///
/// It is required that the keys implement the `Eq` and `Hash` traits, although
-/// this can frequently be achieved by using `#[derive(Eq, Hash)]`.
+/// this can frequently be achieved by using `#[derive(Eq, Hash)]`. If you
+/// implement these yourself, it is important that the following property holds:
+///
+/// ```text
+/// k1 == k2 -> hash(k1) == hash(k2)
+/// ```
+///
+/// In other words, if two keys are equal, their hashes must be equal.
///
/// It is a logic error for a key to be modified in such a way that the key's
/// hash, as determined by the `Hash` trait, or its equality, as determined by
///
/// ```
/// use std::collections::HashMap;
- /// let mut map: HashMap<&str, int> = HashMap::new();
+ /// let mut map: HashMap<&str, isize> = HashMap::new();
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
///
/// ```
/// use std::collections::HashMap;
- /// let mut map: HashMap<&str, int> = HashMap::with_capacity(10);
+ /// let mut map: HashMap<&str, isize> = HashMap::with_capacity(10);
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
///
/// ```
/// use std::collections::HashMap;
- /// let map: HashMap<int, int> = HashMap::with_capacity(100);
+ /// let map: HashMap<isize, isize> = HashMap::with_capacity(100);
/// assert!(map.capacity() >= 100);
/// ```
#[inline]
///
/// ```
/// use std::collections::HashMap;
- /// let mut map: HashMap<&str, int> = HashMap::new();
+ /// let mut map: HashMap<&str, isize> = HashMap::new();
/// map.reserve(10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
/// ```
/// use std::collections::HashMap;
///
- /// let mut map: HashMap<int, int> = HashMap::with_capacity(100);
+ /// let mut map: HashMap<isize, isize> = HashMap::with_capacity(100);
/// map.insert(1, 2);
/// map.insert(3, 4);
/// assert!(map.capacity() >= 100);
}
}
- let robin_ib = bucket.index() as int - bucket.distance() as int;
+ let robin_ib = bucket.index() as isize - bucket.distance() as isize;
- if (ib as int) < robin_ib {
+ if (ib as isize) < robin_ib {
// Found a luckier bucket than me. Better steal his spot.
return robin_hood(bucket, robin_ib as usize, hash, k, v);
}
/// map.insert("c", 3);
///
/// // Not possible with .iter()
- /// let vec: Vec<(&str, int)> = map.into_iter().collect();
+ /// let vec: Vec<(&str, isize)> = map.into_iter().collect();
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_iter(self) -> IntoIter<K, V> {
}
}
- let robin_ib = bucket.index() as int - bucket.distance() as int;
+ let robin_ib = bucket.index() as isize - bucket.distance() as isize;
- if (ib as int) < robin_ib {
+ if (ib as isize) < robin_ib {
// Found a luckier bucket than me. Better steal his spot.
return Vacant(VacantEntry {
hash: hash,
where K: Eq + Hash + Debug, V: Debug, S: HashState
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
-
- for (i, (k, v)) in self.iter().enumerate() {
- if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{:?}: {:?}", *k, *v));
- }
-
- write!(f, "}}")
+ self.iter().fold(f.debug_map(), |b, (k, v)| b.entry(k, v)).finish()
}
}
}
}
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K, Q: ?Sized, V, S> Index<Q> for HashMap<K, V, S>
- where K: Eq + Hash + Borrow<Q>,
- Q: Eq + Hash,
- S: HashState,
-{
- type Output = V;
-
- #[inline]
- fn index<'a>(&'a self, index: &Q) -> &'a V {
- self.get(index).expect("no entry found for key")
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, Q: ?Sized, V, S> Index<&'a Q> for HashMap<K, V, S>
where K: Eq + Hash + Borrow<Q>,
assert_eq!(*m.get(&2).unwrap(), 4);
}
- thread_local! { static DROP_VECTOR: RefCell<Vec<int>> = RefCell::new(Vec::new()) }
+ thread_local! { static DROP_VECTOR: RefCell<Vec<isize>> = RefCell::new(Vec::new()) }
#[derive(Hash, PartialEq, Eq)]
struct Dropable {
#[test]
fn test_empty_pop() {
- let mut m: HashMap<int, bool> = HashMap::new();
+ let mut m: HashMap<isize, bool> = HashMap::new();
assert_eq!(m.remove(&0), None);
}
use fmt::Debug;
use fmt;
use hash::Hash;
-use iter::{
- Iterator, IntoIterator, ExactSizeIterator, IteratorExt, FromIterator, Map, Chain, Extend,
-};
+use iter::{Iterator, IntoIterator, ExactSizeIterator, FromIterator, Map, Chain, Extend};
use ops::{BitOr, BitAnd, BitXor, Sub};
use option::Option::{Some, None, self};
/// An implementation of a hash set using the underlying representation of a
/// HashMap where the value is (). As with the `HashMap` type, a `HashSet`
-/// requires that the elements implement the `Eq` and `Hash` traits.
+/// requires that the elements implement the `Eq` and `Hash` traits. This can
+/// frequently be achieved by using `#[derive(Eq, Hash)]`. If you implement
+/// these yourself, it is important that the following property holds:
+///
+/// ```text
+/// k1 == k2 -> hash(k1) == hash(k2)
+/// ```
+///
+/// In other words, if two keys are equal, their hashes must be equal.
+///
///
/// It is a logic error for an item to be modified in such a way that the
/// item's hash, as determined by the `Hash` trait, or its equality, as
S: HashState
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- try!(write!(f, "{{"));
-
- for (i, x) in self.iter().enumerate() {
- if i != 0 { try!(write!(f, ", ")); }
- try!(write!(f, "{:?}", *x));
- }
-
- write!(f, "}}")
+ self.iter().fold(f.debug_set(), |b, e| b.entry(e)).finish()
}
}
use clone::Clone;
use cmp;
use hash::{Hash, Hasher};
-use iter::{Iterator, IteratorExt, ExactSizeIterator, count};
+use iter::{Iterator, ExactSizeIterator, count};
use marker::{Copy, Send, Sync, Sized, self};
use mem::{min_align_of, size_of};
use mem;
pub fn shift(mut self) -> Option<GapThenFull<K, V, M>> {
unsafe {
*self.gap.raw.hash = mem::replace(&mut *self.full.raw.hash, EMPTY_BUCKET);
- ptr::copy_nonoverlapping(self.gap.raw.key, self.full.raw.key, 1);
- ptr::copy_nonoverlapping(self.gap.raw.val, self.full.raw.val, 1);
+ ptr::copy_nonoverlapping(self.full.raw.key, self.gap.raw.key, 1);
+ ptr::copy_nonoverlapping(self.full.raw.val, self.gap.raw.val, 1);
}
let FullBucket { raw: prev_raw, idx: prev_idx, .. } = self.full;
#[unsafe_destructor]
impl<K, V> Drop for RawTable<K, V> {
fn drop(&mut self) {
- if self.capacity == 0 {
+ if self.capacity == 0 || self.capacity == mem::POST_DROP_USIZE {
return;
}
#![unstable(feature = "std_misc")]
#![allow(missing_docs)]
-#![allow(deprecated)] // will be addressed by #23197
use prelude::v1::*;
use env;
-use ffi::CString;
+use ffi::{AsOsStr, CString, OsString};
use mem;
-use old_path::{Path, GenericPath};
-use os;
-use str;
+use path::{Path, PathBuf};
pub struct DynamicLibrary {
handle: *mut u8
/// Lazily open a dynamic library. When passed None it gives a
/// handle to the calling process
pub fn open(filename: Option<&Path>) -> Result<DynamicLibrary, String> {
- let maybe_library = dl::open(filename.map(|path| path.as_vec()));
+ let maybe_library = dl::open(filename.map(|path| path.as_os_str()));
// The dynamic library must not be constructed if there is
// an error opening the library so the destructor does not
/// Prepends a path to this process's search path for dynamic libraries
pub fn prepend_search_path(path: &Path) {
let mut search_path = DynamicLibrary::search_path();
- search_path.insert(0, path.clone());
- let newval = DynamicLibrary::create_path(&search_path);
- env::set_var(DynamicLibrary::envvar(),
- str::from_utf8(&newval).unwrap());
+ search_path.insert(0, path.to_path_buf());
+ env::set_var(DynamicLibrary::envvar(), &DynamicLibrary::create_path(&search_path));
}
/// From a slice of paths, create a new vector which is suitable to be an
/// environment variable for this platforms dylib search path.
- pub fn create_path(path: &[Path]) -> Vec<u8> {
- let mut newvar = Vec::new();
+ pub fn create_path(path: &[PathBuf]) -> OsString {
+ let mut newvar = OsString::new();
for (i, path) in path.iter().enumerate() {
if i > 0 { newvar.push(DynamicLibrary::separator()); }
- newvar.push_all(path.as_vec());
+ newvar.push(path);
}
return newvar;
}
}
}
- fn separator() -> u8 {
- if cfg!(windows) {b';'} else {b':'}
+ fn separator() -> &'static str {
+ if cfg!(windows) { ";" } else { ":" }
}
/// Returns the current search path for dynamic libraries being used by this
/// process
- pub fn search_path() -> Vec<Path> {
+ pub fn search_path() -> Vec<PathBuf> {
match env::var_os(DynamicLibrary::envvar()) {
- Some(var) => os::split_paths(var.to_str().unwrap()),
+ Some(var) => env::split_paths(&var).collect(),
None => Vec::new(),
}
}
use super::*;
use prelude::v1::*;
use libc;
- use old_path::Path;
use mem;
+ use path::Path;
#[test]
#[cfg_attr(any(windows, target_os = "android"), ignore)] // FIXME #8818, #10379
mod dl {
use prelude::v1::*;
- use ffi::{CString, CStr};
+ use ffi::{CStr, OsStr};
use str;
use libc;
+ use os::unix::prelude::*;
use ptr;
- pub fn open(filename: Option<&[u8]>) -> Result<*mut u8, String> {
+ pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> {
check_for_errors_in(|| {
unsafe {
match filename {
const LAZY: libc::c_int = 1;
- unsafe fn open_external(filename: &[u8]) -> *mut u8 {
- let s = CString::new(filename).unwrap();
+ unsafe fn open_external(filename: &OsStr) -> *mut u8 {
+ let s = filename.to_cstring().unwrap();
dlopen(s.as_ptr(), LAZY) as *mut u8
}
#[cfg(target_os = "windows")]
mod dl {
- use iter::IteratorExt;
+ use ffi::OsStr;
+ use iter::Iterator;
use libc;
use libc::consts::os::extra::ERROR_CALL_NOT_IMPLEMENTED;
use ops::FnOnce;
- use os;
+ use sys::os;
+ use os::windows::prelude::*;
use option::Option::{self, Some, None};
use ptr;
use result::Result;
use result::Result::{Ok, Err};
- use str;
use string::String;
use vec::Vec;
use sys::c::compat::kernel32::SetThreadErrorMode;
- pub fn open(filename: Option<&[u8]>) -> Result<*mut u8, String> {
+ pub fn open(filename: Option<&OsStr>) -> Result<*mut u8, String> {
// disable "dll load failed" error dialog.
let mut use_thread_mode = true;
let prev_error_mode = unsafe {
let result = match filename {
Some(filename) => {
- let filename_str = str::from_utf8(filename).unwrap();
- let mut filename_str: Vec<u16> = filename_str.utf16_units().collect();
- filename_str.push(0);
+ let filename_str: Vec<_> =
+ filename.encode_wide().chain(Some(0).into_iter()).collect();
let result = unsafe {
LoadLibraryW(filename_str.as_ptr() as *const libc::c_void)
};
use error::{Error, FromError};
use fmt;
use io;
-use iter::IteratorExt;
+use iter::Iterator;
use libc;
use mem;
#[allow(deprecated)]
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a String> for OsString {
- fn from(s: &'a String) -> OsString {
- OsString { inner: Buf::from_str(s) }
+impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for OsString {
+ fn from(s: &'a T) -> OsString {
+ s.as_ref().to_os_string()
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for OsString {
- fn from(s: &'a str) -> OsString {
- OsString { inner: Buf::from_str(s) }
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a OsStr> for OsString {
- fn from(s: &'a OsStr) -> OsString {
- OsString { inner: s.inner.to_owned() }
- }
-}
-
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFull> for OsString {
- type Output = OsStr;
-
- #[inline]
- fn index(&self, _index: &ops::RangeFull) -> &OsStr {
- unsafe { mem::transmute(self.inner.as_slice()) }
- }
-}
-
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::RangeFull> for OsString {
type Output = OsStr;
assert_eq!(v, b"foobar\0\0\0\0".to_vec());
// Truncate to a smaller length, don't seek, and then write something.
- // Ensure that the intermediate zeroes are all filled in (we're seeked
+ // Ensure that the intermediate zeroes are all filled in (we have `seek`ed
// past the end of the file).
check!(file.set_len(2));
assert_eq!(check!(file.metadata()).len(), 2);
// be enough to dissuade an attacker from trying to preemptively create names
// of that length, but not so huge that we unnecessarily drain the random number
// generator of entropy.
-const NUM_RAND_CHARS: uint = 12;
+const NUM_RAND_CHARS: usize = 12;
impl TempDir {
/// Attempts to make a temporary directory inside of `tmpdir` whose name
use cmp;
use error::{self, FromError};
use fmt;
-use io::{self, Cursor, DEFAULT_BUF_SIZE, Error, ErrorKind};
+use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind};
use ptr;
+use iter;
/// Wraps a `Read` and buffers input from it
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct BufReader<R> {
inner: R,
- buf: Cursor<Vec<u8>>,
+ buf: Vec<u8>,
+ pos: usize,
+ cap: usize,
}
impl<R: Read> BufReader<R> {
/// Creates a new `BufReader` with the specified buffer capacity
#[stable(feature = "rust1", since = "1.0.0")]
pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
+ let mut buf = Vec::with_capacity(cap);
+ buf.extend(iter::repeat(0).take(cap));
BufReader {
inner: inner,
- buf: Cursor::new(Vec::with_capacity(cap)),
+ buf: buf,
+ pos: 0,
+ cap: 0,
}
}
// If we don't have any buffered data and we're doing a massive read
// (larger than our internal buffer), bypass our internal buffer
// entirely.
- if self.buf.get_ref().len() == self.buf.position() as usize &&
- buf.len() >= self.buf.get_ref().capacity() {
+ if self.pos == self.cap && buf.len() >= self.buf.len() {
return self.inner.read(buf);
}
- try!(self.fill_buf());
- self.buf.read(buf)
+ let nread = {
+ let mut rem = try!(self.fill_buf());
+ try!(rem.read(buf))
+ };
+ self.consume(nread);
+ Ok(nread)
}
}
fn fill_buf(&mut self) -> io::Result<&[u8]> {
// If we've reached the end of our internal buffer then we need to fetch
// some more data from the underlying reader.
- if self.buf.position() as usize == self.buf.get_ref().len() {
- self.buf.set_position(0);
- let v = self.buf.get_mut();
- v.truncate(0);
- let inner = &mut self.inner;
- try!(super::with_end_to_cap(v, |b| inner.read(b)));
+ if self.pos == self.cap {
+ self.cap = try!(self.inner.read(&mut self.buf));
+ self.pos = 0;
}
- self.buf.fill_buf()
+ Ok(&self.buf[self.pos..self.cap])
}
- fn consume(&mut self, amt: uint) {
- self.buf.consume(amt)
+ fn consume(&mut self, amt: usize) {
+ self.pos = cmp::min(self.pos + amt, self.cap);
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- write!(fmt, "BufReader {{ reader: {:?}, buffer: {}/{} }}",
- self.inner, self.buf.position(), self.buf.get_ref().len())
+ fmt.debug_struct("BufReader")
+ .field("reader", &self.inner)
+ .field("buffer", &format_args!("{}/{}", self.cap - self.pos, self.buf.len()))
+ .finish()
}
}
if written > 0 {
// NB: would be better expressed as .remove(0..n) if it existed
unsafe {
- ptr::copy(self.buf.as_mut_ptr(),
- self.buf.as_ptr().offset(written as isize),
+ ptr::copy(self.buf.as_ptr().offset(written as isize),
+ self.buf.as_mut_ptr(),
len - written);
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- write!(fmt, "BufWriter {{ writer: {:?}, buffer: {}/{} }}",
- self.inner.as_ref().unwrap(), self.buf.len(), self.buf.capacity())
+ fmt.debug_struct("BufWriter")
+ .field("writer", &self.inner.as_ref().unwrap())
+ .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
+ .finish()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- write!(fmt, "LineWriter {{ writer: {:?}, buffer: {}/{} }}",
- self.inner.inner, self.inner.buf.len(),
- self.inner.buf.capacity())
+ fmt.debug_struct("LineWriter")
+ .field("writer", &self.inner.inner)
+ .field("buffer",
+ &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()))
+ .finish()
}
}
/// Any leftover data in the read buffer is lost.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_inner(self) -> Result<S, IntoInnerError<BufStream<S>>> {
- let BufReader { inner: InternalBufWriter(w), buf } = self.inner;
+ let BufReader { inner: InternalBufWriter(w), buf, pos, cap } = self.inner;
w.into_inner().map_err(|IntoInnerError(w, e)| {
IntoInnerError(BufStream {
- inner: BufReader { inner: InternalBufWriter(w), buf: buf },
+ inner: BufReader { inner: InternalBufWriter(w), buf: buf, pos: pos, cap: cap },
}, e)
})
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<S: Read + Write> BufRead for BufStream<S> {
fn fill_buf(&mut self) -> io::Result<&[u8]> { self.inner.fill_buf() }
- fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
+ fn consume(&mut self, amt: usize) { self.inner.consume(amt) }
}
#[stable(feature = "rust1", since = "1.0.0")]
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let reader = &self.inner;
let writer = &self.inner.inner.0;
- write!(fmt, "BufStream {{ stream: {:?}, write_buffer: {}/{}, read_buffer: {}/{} }}",
- writer.inner,
- writer.buf.len(), writer.buf.capacity(),
- reader.buf.position(), reader.buf.get_ref().len())
+ fmt.debug_struct("BufStream")
+ .field("stream", &writer.inner)
+ .field("write_buffer", &format_args!("{}/{}", writer.buf.len(), writer.buf.capacity()))
+ .field("read_buffer",
+ &format_args!("{}/{}", reader.cap - reader.pos, reader.buf.len()))
+ .finish()
}
}
}
#[test]
- #[should_fail]
+ #[should_panic]
fn dont_panic_in_drop_on_panicked_flush() {
struct FailFlushWriter;
use cmp;
use io::{self, SeekFrom, Error, ErrorKind};
use iter::repeat;
-use num::Int;
use slice;
/// A `Cursor` is a type which wraps a non-I/O object to provide a `Seek`
// there (left), and what will be appended on the end (right)
let space = self.inner.len() - pos as usize;
let (left, right) = buf.split_at(cmp::min(space, buf.len()));
- slice::bytes::copy_memory(&mut self.inner[(pos as usize)..], left);
+ slice::bytes::copy_memory(left, &mut self.inner[(pos as usize)..]);
self.inner.push_all(right);
// Bump us forward
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let amt = cmp::min(buf.len(), self.len());
let (a, b) = self.split_at(amt);
- slice::bytes::copy_memory(buf, a);
+ slice::bytes::copy_memory(a, buf);
*self = b;
Ok(amt)
}
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
let amt = cmp::min(data.len(), self.len());
let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
- slice::bytes::copy_memory(a, &data[..amt]);
+ slice::bytes::copy_memory(&data[..amt], a);
*self = b;
Ok(amt)
}
use unicode::str as core_str;
use error as std_error;
use fmt;
-use iter::{self, Iterator, IteratorExt, Extend};
+use iter::{self, Iterator, Extend};
use marker::Sized;
use ops::{Drop, FnOnce};
use option::Option::{self, Some, None};
const DEFAULT_BUF_SIZE: usize = 64 * 1024;
-// Acquires a slice of the vector `v` from its length to its capacity
-// (after initializing the data), reads into it, and then updates the length.
-//
-// This function is leveraged to efficiently read some bytes into a destination
-// vector without extra copying and taking advantage of the space that's already
-// in `v`.
-fn with_end_to_cap<F>(v: &mut Vec<u8>, f: F) -> Result<usize>
- where F: FnOnce(&mut [u8]) -> Result<usize>
-{
- let len = v.len();
- let new_area = v.capacity() - len;
- v.extend(iter::repeat(0).take(new_area));
- match f(&mut v[len..]) {
- Ok(n) => {
- v.truncate(len + n);
- Ok(n)
- }
- Err(e) => {
- v.truncate(len);
- Err(e)
- }
- }
-}
-
// A few methods below (read_to_string, read_line) will append data into a
// `String` buffer, but we need to be pretty careful when doing this. The
// implementation will just call `.as_mut_vec()` and then delegate to a
}
}
+// This uses an adaptive system to extend the vector when it fills. We want to
+// avoid paying to allocate and zero a huge chunk of memory if the reader only
+// has 4 bytes while still making large reads if the reader does have a ton
+// of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every
+// time is 4,500 times (!) slower than this if the reader has a very small
+// amount of data to return.
fn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
- let mut read = 0;
+ let start_len = buf.len();
+ let mut len = start_len;
+ let mut cap_bump = 16;
+ let ret;
loop {
- if buf.capacity() == buf.len() {
- buf.reserve(DEFAULT_BUF_SIZE);
+ if len == buf.len() {
+ if buf.capacity() == buf.len() {
+ if cap_bump < DEFAULT_BUF_SIZE {
+ cap_bump *= 2;
+ }
+ buf.reserve(cap_bump);
+ }
+ let new_area = buf.capacity() - buf.len();
+ buf.extend(iter::repeat(0).take(new_area));
}
- match with_end_to_cap(buf, |b| r.read(b)) {
- Ok(0) => return Ok(read),
- Ok(n) => read += n,
+
+ match r.read(&mut buf[len..]) {
+ Ok(0) => {
+ ret = Ok(len - start_len);
+ break;
+ }
+ Ok(n) => len += n,
Err(ref e) if e.kind() == ErrorKind::Interrupted => {}
- Err(e) => return Err(e),
+ Err(e) => {
+ ret = Err(e);
+ break;
+ }
}
}
+
+ buf.truncate(len);
+ ret
}
/// A trait for objects which are byte-oriented sources.
///
/// This function will yield errors whenever `read_until` would have also
/// yielded an error.
- #[unstable(feature = "io", reason = "may be renamed to not conflict with \
- SliceExt::split")]
+ #[stable(feature = "rust1", since = "1.0.0")]
fn split(self, byte: u8) -> Split<Self> where Self: Sized {
Split { buf: self, delim: byte }
}
/// particular byte.
///
/// See `BufReadExt::split` for more information.
-#[unstable(feature = "io", reason = "awaiting stability of BufReadExt::split")]
+#[stable(feature = "rust1", since = "1.0.0")]
pub struct Split<B> {
buf: B,
delim: u8,
}
-#[unstable(feature = "io", reason = "awaiting stability of BufReadExt::split")]
+#[stable(feature = "rust1", since = "1.0.0")]
impl<B: BufRead> Iterator for Split<B> {
type Item = Result<Vec<u8>>;
use prelude::v1::*;
use io::prelude::*;
-use cell::RefCell;
+use cell::{RefCell, BorrowState};
use cmp;
use fmt;
use io::lazy::Lazy;
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
self.lock().write_all(buf)
}
- fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
- self.lock().write_fmt(fmt)
- }
+ // Don't override write_fmt as it's possible to run arbitrary code during a
+ // write_fmt, allowing the possibility of a recursive lock (aka deadlock)
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Write for StdoutLock<'a> {
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
self.lock().write_all(buf)
}
- fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
- self.lock().write_fmt(fmt)
- }
+ // Don't override write_fmt for the same reasons as Stdout
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Write for StderrLock<'a> {
reason = "implementation detail which may disappear or be replaced at any time")]
#[doc(hidden)]
pub fn _print(args: fmt::Arguments) {
- if let Err(e) = LOCAL_STDOUT.with(|s| match s.borrow_mut().as_mut() {
- Some(w) => w.write_fmt(args),
- None => stdout().write_fmt(args)
- }) {
+ let result = LOCAL_STDOUT.with(|s| {
+ if s.borrow_state() == BorrowState::Unused {
+ if let Some(w) = s.borrow_mut().as_mut() {
+ return w.write_fmt(args);
+ }
+ }
+ stdout().write_fmt(args)
+ });
+ if let Err(e) = result {
panic!("failed printing to stdout: {}", e);
}
}
//! module encapsulates the platform-specific rules for dealing
//! with file paths.
//!
-//! `std` also includes modules for interoperating with the
-//! C language: [`c_str`](c_str/index.html) and
-//! [`c_vec`](c_vec/index.html).
+//! `std` also includes the [`ffi`](ffi/index.html) module for interoperating
+//! with the C language.
//!
//! ## Concurrency, I/O, and the runtime
//!
#![feature(lang_items)]
#![feature(libc)]
#![feature(linkage, thread_local, asm)]
-#![feature(old_impl_check)]
#![feature(optin_builtin_traits)]
#![feature(rand)]
#![feature(staged_api)]
#![feature(unboxed_closures)]
#![feature(unicode)]
#![feature(unsafe_destructor)]
-#![feature(unsafe_no_drop_flag)]
+#![feature(unsafe_no_drop_flag, filling_drop)]
#![feature(macro_reexport)]
-#![feature(int_uint)]
#![feature(unique)]
#![feature(convert)]
#![feature(allow_internal_unstable)]
#![feature(str_char)]
#![feature(into_cow)]
+#![feature(slice_patterns)]
+#![feature(std_misc)]
+#![feature(debug_builders)]
#![cfg_attr(test, feature(test, rustc_private, std_misc))]
// Don't link to std. We are std.
#![no_std]
#![allow(trivial_casts)]
-#![allow(trivial_numeric_casts)]
#![deny(missing_docs)]
#[cfg(test)] extern crate test;
#[macro_use]
#[macro_reexport(vec, format)]
-extern crate "collections" as core_collections;
+extern crate collections as core_collections;
-#[allow(deprecated)] extern crate "rand" as core_rand;
+#[allow(deprecated)] extern crate rand as core_rand;
extern crate alloc;
extern crate unicode;
extern crate libc;
#[macro_use] #[no_link] extern crate rustc_bitflags;
// Make std testable by not duplicating lang items. See #2912
-#[cfg(test)] extern crate "std" as realstd;
+#[cfg(test)] extern crate std as realstd;
#[cfg(test)] pub use realstd::marker;
#[cfg(test)] pub use realstd::ops;
#[cfg(test)] pub use realstd::cmp;
///
/// # Examples
///
-/// ```should_fail
+/// ```should_panic
/// # #![allow(unreachable_code)]
/// panic!();
/// panic!("this is a terrible mistake!");
///
/// Equivalent to the `println!` macro except that a newline is not printed at
/// the end of the message.
+///
+/// Note that stdout is frequently line-buffered by default so it may be
+/// necessary to use `io::stdout().flush()` to ensure the output is emitted
+/// immediately.
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
#[allow_internal_unstable]
use prelude::v1::*;
use io::{self, Error, ErrorKind};
+#[allow(deprecated)] // Int
use num::Int;
use sys_common::net2 as net_imp;
Both,
}
+#[allow(deprecated)] // Int
fn hton<I: Int>(i: I) -> I { i.to_be() }
+#[allow(deprecated)] // Int
fn ntoh<I: Int>(i: I) -> I { Int::from_be(i) }
fn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T>
use prelude::v1::*;
use str::FromStr;
-use net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
+use net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
struct Parser<'a> {
// parsing as ASCII, so can use byte array
pos: usize,
}
-enum IpAddr {
- V4(Ipv4Addr),
- V6(Ipv6Addr),
-}
-
impl<'a> Parser<'a> {
fn new(s: &'a str) -> Parser<'a> {
Parser {
}
}
+#[unstable(feature = "ip_addr", reason = "recent addition")]
+impl FromStr for IpAddr {
+ type Err = AddrParseError;
+ fn from_str(s: &str) -> Result<IpAddr, AddrParseError> {
+ match Parser::new(s).read_till_eof(|p| p.read_ip_addr()) {
+ Some(s) => Ok(s),
+ None => Err(AddrParseError(()))
+ }
+ }
+}
+
#[stable(feature = "rust1", since = "1.0.0")]
impl FromStr for Ipv4Addr {
type Err = AddrParseError;
}
#[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
impl Float for f32 {
#[inline]
fn nan() -> f32 { num::Float::nan() }
#[allow(deprecated)]
#[inline]
- fn mantissa_digits(unused_self: Option<f32>) -> uint {
+ fn mantissa_digits(unused_self: Option<f32>) -> usize {
num::Float::mantissa_digits(unused_self)
}
#[allow(deprecated)]
#[inline]
- fn digits(unused_self: Option<f32>) -> uint { num::Float::digits(unused_self) }
+ fn digits(unused_self: Option<f32>) -> usize { num::Float::digits(unused_self) }
#[allow(deprecated)]
#[inline]
fn epsilon() -> f32 { num::Float::epsilon() }
#[allow(deprecated)]
#[inline]
- fn min_exp(unused_self: Option<f32>) -> int { num::Float::min_exp(unused_self) }
+ fn min_exp(unused_self: Option<f32>) -> isize { num::Float::min_exp(unused_self) }
#[allow(deprecated)]
#[inline]
- fn max_exp(unused_self: Option<f32>) -> int { num::Float::max_exp(unused_self) }
+ fn max_exp(unused_self: Option<f32>) -> isize { num::Float::max_exp(unused_self) }
#[allow(deprecated)]
#[inline]
- fn min_10_exp(unused_self: Option<f32>) -> int { num::Float::min_10_exp(unused_self) }
+ fn min_10_exp(unused_self: Option<f32>) -> isize { num::Float::min_10_exp(unused_self) }
#[allow(deprecated)]
#[inline]
- fn max_10_exp(unused_self: Option<f32>) -> int { num::Float::max_10_exp(unused_self) }
+ fn max_10_exp(unused_self: Option<f32>) -> isize { num::Float::max_10_exp(unused_self) }
#[allow(deprecated)]
#[inline]
fn min_value() -> f32 { num::Float::min_value() }
/// - `self = x * pow(2, exp)`
/// - `0.5 <= abs(x) < 1.0`
#[inline]
- fn frexp(self) -> (f32, int) {
+ fn frexp(self) -> (f32, isize) {
unsafe {
let mut exp = 0;
let x = cmath::frexpf(self, &mut exp);
- (x, exp as int)
+ (x, exp as isize)
}
}
#[lang = "f32"]
#[stable(feature = "rust1", since = "1.0.0")]
impl f32 {
- // inlined methods from `num::Float`
- /// Returns the `NaN` value.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let nan: f32 = Float::nan();
- ///
- /// assert!(nan.is_nan());
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn nan() -> f32 { num::Float::nan() }
-
- /// Returns the infinite value.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f32;
- ///
- /// let infinity: f32 = Float::infinity();
- ///
- /// assert!(infinity.is_infinite());
- /// assert!(!infinity.is_finite());
- /// assert!(infinity > f32::MAX);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn infinity() -> f32 { num::Float::infinity() }
-
- /// Returns the negative infinite value.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f32;
- ///
- /// let neg_infinity: f32 = Float::neg_infinity();
- ///
- /// assert!(neg_infinity.is_infinite());
- /// assert!(!neg_infinity.is_finite());
- /// assert!(neg_infinity < f32::MIN);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn neg_infinity() -> f32 { num::Float::neg_infinity() }
-
- /// Returns `0.0`.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let inf: f32 = Float::infinity();
- /// let zero: f32 = Float::zero();
- /// let neg_zero: f32 = Float::neg_zero();
- ///
- /// assert_eq!(zero, neg_zero);
- /// assert_eq!(7.0f32/inf, zero);
- /// assert_eq!(zero * 10.0, zero);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn zero() -> f32 { num::Float::zero() }
-
- /// Returns `-0.0`.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let inf: f32 = Float::infinity();
- /// let zero: f32 = Float::zero();
- /// let neg_zero: f32 = Float::neg_zero();
- ///
- /// assert_eq!(zero, neg_zero);
- /// assert_eq!(7.0f32/inf, zero);
- /// assert_eq!(zero * 10.0, zero);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn neg_zero() -> f32 { num::Float::neg_zero() }
-
- /// Returns `1.0`.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let one: f32 = Float::one();
- ///
- /// assert_eq!(one, 1.0f32);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn one() -> f32 { num::Float::one() }
-
- // FIXME (#5527): These should be associated constants
-
- /// Deprecated: use `std::f32::MANTISSA_DIGITS` or `std::f64::MANTISSA_DIGITS`
- /// instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MANTISSA_DIGITS` or \
- `std::f64::MANTISSA_DIGITS` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn mantissa_digits(unused_self: Option<f32>) -> uint {
- num::Float::mantissa_digits(unused_self)
- }
-
- /// Deprecated: use `std::f32::DIGITS` or `std::f64::DIGITS` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn digits(unused_self: Option<f32>) -> uint { num::Float::digits(unused_self) }
-
- /// Deprecated: use `std::f32::EPSILON` or `std::f64::EPSILON` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn epsilon() -> f32 { num::Float::epsilon() }
-
- /// Deprecated: use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn min_exp(unused_self: Option<f32>) -> int { num::Float::min_exp(unused_self) }
-
- /// Deprecated: use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn max_exp(unused_self: Option<f32>) -> int { num::Float::max_exp(unused_self) }
-
- /// Deprecated: use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn min_10_exp(unused_self: Option<f32>) -> int { num::Float::min_10_exp(unused_self) }
-
- /// Deprecated: use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn max_10_exp(unused_self: Option<f32>) -> int { num::Float::max_10_exp(unused_self) }
-
- /// Returns the smallest finite value that this type can represent.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::min_value();
- ///
- /// assert_eq!(x, f64::MIN);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- #[allow(deprecated)]
- pub fn min_value() -> f32 { num::Float::min_value() }
-
- /// Returns the smallest normalized positive number that this type can represent.
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- #[allow(deprecated)]
- pub fn min_pos_value(unused_self: Option<f32>) -> f32 { num::Float::min_pos_value(unused_self) }
-
- /// Returns the largest finite value that this type can represent.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::max_value();
- /// assert_eq!(x, f64::MAX);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- #[allow(deprecated)]
- pub fn max_value() -> f32 { num::Float::max_value() }
-
/// Returns `true` if this value is `NaN` and false otherwise.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let nan = f64::NAN;
- /// let f = 7.0;
+ /// let nan = f32::NAN;
+ /// let f = 7.0_f32;
///
/// assert!(nan.is_nan());
/// assert!(!f.is_nan());
/// ```
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_nan(self) -> bool { num::Float::is_nan(self) }
/// false otherwise.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
/// use std::f32;
///
/// let f = 7.0f32;
- /// let inf: f32 = Float::infinity();
- /// let neg_inf: f32 = Float::neg_infinity();
- /// let nan: f32 = f32::NAN;
+ /// let inf = f32::INFINITY;
+ /// let neg_inf = f32::NEG_INFINITY;
+ /// let nan = f32::NAN;
///
/// assert!(!f.is_infinite());
/// assert!(!nan.is_infinite());
/// assert!(inf.is_infinite());
/// assert!(neg_inf.is_infinite());
/// ```
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_infinite(self) -> bool { num::Float::is_infinite(self) }
/// Returns `true` if this number is neither infinite nor `NaN`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
/// use std::f32;
///
/// let f = 7.0f32;
- /// let inf: f32 = Float::infinity();
- /// let neg_inf: f32 = Float::neg_infinity();
- /// let nan: f32 = f32::NAN;
+ /// let inf = f32::INFINITY;
+ /// let neg_inf = f32::NEG_INFINITY;
+ /// let nan = f32::NAN;
///
/// assert!(f.is_finite());
///
/// assert!(!inf.is_finite());
/// assert!(!neg_inf.is_finite());
/// ```
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_finite(self) -> bool { num::Float::is_finite(self) }
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
/// use std::f32;
///
/// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
/// let max = f32::MAX;
/// let lower_than_min = 1.0e-40_f32;
- /// let zero = 0.0f32;
+ /// let zero = 0.0_f32;
///
/// assert!(min.is_normal());
/// assert!(max.is_normal());
/// assert!(!lower_than_min.is_normal());
/// ```
/// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_normal(self) -> bool { num::Float::is_normal(self) }
/// predicate instead.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::{Float, FpCategory};
+ /// use std::num::FpCategory;
/// use std::f32;
///
- /// let num = 12.4f32;
+ /// let num = 12.4_f32;
/// let inf = f32::INFINITY;
///
/// assert_eq!(num.classify(), FpCategory::Normal);
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
/// let num = 2.0f32;
///
/// // 1 * 8388608 * 2^(-22) == 2
/// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
/// [floating-point]: ../../../../../reference.html#machine-types
#[unstable(feature = "std_misc", reason = "signature is undecided")]
/// Returns the largest integer less than or equal to a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.99;
- /// let g = 3.0;
+ /// let f = 3.99_f32;
+ /// let g = 3.0_f32;
///
/// assert_eq!(f.floor(), 3.0);
/// assert_eq!(g.floor(), 3.0);
/// Returns the smallest integer greater than or equal to a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.01;
- /// let g = 4.0;
+ /// let f = 3.01_f32;
+ /// let g = 4.0_f32;
///
/// assert_eq!(f.ceil(), 4.0);
/// assert_eq!(g.ceil(), 4.0);
/// `0.0`.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.3;
- /// let g = -3.3;
+ /// let f = 3.3_f32;
+ /// let g = -3.3_f32;
///
/// assert_eq!(f.round(), 3.0);
/// assert_eq!(g.round(), -3.0);
/// Return the integer part of a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.3;
- /// let g = -3.7;
+ /// let f = 3.3_f32;
+ /// let g = -3.7_f32;
///
/// assert_eq!(f.trunc(), 3.0);
/// assert_eq!(g.trunc(), -3.0);
/// Returns the fractional part of a number.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 3.5;
- /// let y = -3.5;
+ /// let x = 3.5_f32;
+ /// let y = -3.5_f32;
/// let abs_difference_x = (x.fract() - 0.5).abs();
/// let abs_difference_y = (y.fract() - (-0.5)).abs();
///
- /// assert!(abs_difference_x < 1e-10);
- /// assert!(abs_difference_y < 1e-10);
+ /// assert!(abs_difference_x <= f32::EPSILON);
+ /// assert!(abs_difference_y <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn fract(self) -> f32 { num::Float::fract(self) }
- /// Computes the absolute value of `self`. Returns `Float::nan()` if the
- /// number is `Float::nan()`.
+ /// Computes the absolute value of `self`. Returns `NAN` if the
+ /// number is `NAN`.
///
/// ```
- /// # #![feature(core, std_misc)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let x = 3.5;
- /// let y = -3.5;
+ /// let x = 3.5_f32;
+ /// let y = -3.5_f32;
///
/// let abs_difference_x = (x.abs() - x).abs();
/// let abs_difference_y = (y.abs() - (-y)).abs();
///
- /// assert!(abs_difference_x < 1e-10);
- /// assert!(abs_difference_y < 1e-10);
+ /// assert!(abs_difference_x <= f32::EPSILON);
+ /// assert!(abs_difference_y <= f32::EPSILON);
///
- /// assert!(f64::NAN.abs().is_nan());
+ /// assert!(f32::NAN.abs().is_nan());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns a number that represents the sign of `self`.
///
- /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
- /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
- /// - `Float::nan()` if the number is `Float::nan()`
+ /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
+ /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+ /// - `NAN` if the number is `NAN`
///
/// ```
- /// # #![feature(core, std_misc)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let f = 3.5;
+ /// let f = 3.5_f32;
///
/// assert_eq!(f.signum(), 1.0);
- /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);
+ /// assert_eq!(f32::NEG_INFINITY.signum(), -1.0);
///
- /// assert!(f64::NAN.signum().is_nan());
+ /// assert!(f32::NAN.signum().is_nan());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn signum(self) -> f32 { num::Float::signum(self) }
- /// Returns `true` if `self` is positive, including `+0.0` and
- /// `Float::infinity()`.
+ /// Returns `true` if `self`'s sign bit is positive, including
+ /// `+0.0` and `INFINITY`.
///
/// ```
- /// use std::num::Float;
- /// use std::f64;
- ///
- /// let nan: f64 = f64::NAN;
+ /// use std::f32;
///
- /// let f = 7.0;
- /// let g = -7.0;
+ /// let nan = f32::NAN;
+ /// let f = 7.0_f32;
+ /// let g = -7.0_f32;
///
- /// assert!(f.is_positive());
- /// assert!(!g.is_positive());
+ /// assert!(f.is_sign_positive());
+ /// assert!(!g.is_sign_positive());
/// // Requires both tests to determine if is `NaN`
- /// assert!(!nan.is_positive() && !nan.is_negative());
+ /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ pub fn is_sign_positive(self) -> bool { num::Float::is_positive(self) }
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to is_sign_positive")]
+ #[inline]
pub fn is_positive(self) -> bool { num::Float::is_positive(self) }
- /// Returns `true` if `self` is negative, including `-0.0` and
- /// `Float::neg_infinity()`.
+ /// Returns `true` if `self`'s sign is negative, including `-0.0`
+ /// and `NEG_INFINITY`.
///
/// ```
- /// use std::num::Float;
- /// use std::f64;
- ///
- /// let nan = f64::NAN;
+ /// use std::f32;
///
- /// let f = 7.0;
- /// let g = -7.0;
+ /// let nan = f32::NAN;
+ /// let f = 7.0f32;
+ /// let g = -7.0f32;
///
- /// assert!(!f.is_negative());
- /// assert!(g.is_negative());
+ /// assert!(!f.is_sign_negative());
+ /// assert!(g.is_sign_negative());
/// // Requires both tests to determine if is `NaN`.
- /// assert!(!nan.is_positive() && !nan.is_negative());
+ /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ pub fn is_sign_negative(self) -> bool { num::Float::is_negative(self) }
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to is_sign_negative")]
+ #[inline]
pub fn is_negative(self) -> bool { num::Float::is_negative(self) }
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
/// a separate multiplication operation followed by an add.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let m = 10.0;
- /// let x = 4.0;
- /// let b = 60.0;
+ /// let m = 10.0_f32;
+ /// let x = 4.0_f32;
+ /// let b = 60.0_f32;
///
/// // 100.0
/// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn mul_add(self, a: f32, b: f32) -> f32 { num::Float::mul_add(self, a, b) }
/// Take the reciprocal (inverse) of a number, `1/x`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 2.0;
+ /// let x = 2.0_f32;
/// let abs_difference = (x.recip() - (1.0/x)).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn recip(self) -> f32 { num::Float::recip(self) }
/// Using this function is generally faster than using `powf`
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 2.0;
+ /// let x = 2.0_f32;
/// let abs_difference = (x.powi(2) - x*x).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Raise a number to a floating point power.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 2.0;
+ /// let x = 2.0_f32;
/// let abs_difference = (x.powf(2.0) - x*x).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns NaN if `self` is a negative number.
///
/// ```
- /// # #![feature(core, std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let positive = 4.0;
- /// let negative = -4.0;
+ /// let positive = 4.0_f32;
+ /// let negative = -4.0_f32;
///
/// let abs_difference = (positive.sqrt() - 2.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// assert!(negative.sqrt().is_nan());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn sqrt(self) -> f32 { num::Float::sqrt(self) }
-
/// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let f = 4.0;
+ /// let f = 4.0f32;
///
/// let abs_difference = (f.rsqrt() - 0.5).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
+ #[deprecated(since = "1.0.0", reason = "use self.sqrt().recip() instead")]
#[inline]
pub fn rsqrt(self) -> f32 { num::Float::rsqrt(self) }
/// Returns `e^(self)`, (the exponential function).
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let one = 1.0;
+ /// let one = 1.0f32;
/// // e^1
/// let e = one.exp();
///
/// // ln(e) - 1 == 0
/// let abs_difference = (e.ln() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns `2^(self)`.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let f = 2.0;
+ /// let f = 2.0f32;
///
/// // 2^2 - 4 == 0
/// let abs_difference = (f.exp2() - 4.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns the natural logarithm of the number.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let one = 1.0;
+ /// let one = 1.0f32;
/// // e^1
/// let e = one.exp();
///
/// // ln(e) - 1 == 0
/// let abs_difference = (e.ln() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns the logarithm of the number with respect to an arbitrary base.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let ten = 10.0;
- /// let two = 2.0;
+ /// let ten = 10.0f32;
+ /// let two = 2.0f32;
///
/// // log10(10) - 1 == 0
/// let abs_difference_10 = (ten.log(10.0) - 1.0).abs();
/// // log2(2) - 1 == 0
/// let abs_difference_2 = (two.log(2.0) - 1.0).abs();
///
- /// assert!(abs_difference_10 < 1e-10);
- /// assert!(abs_difference_2 < 1e-10);
+ /// assert!(abs_difference_10 <= f32::EPSILON);
+ /// assert!(abs_difference_2 <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns the base 2 logarithm of the number.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let two = 2.0;
+ /// let two = 2.0f32;
///
/// // log2(2) - 1 == 0
/// let abs_difference = (two.log2() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Returns the base 10 logarithm of the number.
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let ten = 10.0;
+ /// let ten = 10.0f32;
///
/// // log10(10) - 1 == 0
/// let abs_difference = (ten.log10() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
///
/// ```
/// # #![feature(std_misc, core)]
- /// use std::num::Float;
- /// use std::f64::consts;
+ /// use std::f32::{self, consts};
///
/// let angle = consts::PI;
///
/// let abs_difference = (angle.to_degrees() - 180.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[unstable(feature = "std_misc", reason = "desirability is unclear")]
#[inline]
/// Convert degrees to radians.
///
/// ```
- /// # #![feature(std_misc, core)]
- /// use std::num::Float;
- /// use std::f64::consts;
+ /// # #![feature(std_misc)]
+ /// use std::f32::{self, consts};
///
- /// let angle = 180.0;
+ /// let angle = 180.0f32;
///
/// let abs_difference = (angle.to_radians() - consts::PI).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[unstable(feature = "std_misc", reason = "desirability is unclear")]
#[inline]
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
+ /// use std::f32;
/// // 3*2^2 - 12 == 0
- /// let abs_difference = (Float::ldexp(3.0, 2) - 12.0).abs();
+ /// let abs_difference = (f32::ldexp(3.0, 2) - 12.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[unstable(feature = "std_misc",
reason = "pending integer conventions")]
#[inline]
- pub fn ldexp(x: f32, exp: int) -> f32 {
+ pub fn ldexp(x: f32, exp: isize) -> f32 {
unsafe { cmath::ldexpf(x, exp as c_int) }
}
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 4.0;
+ /// let x = 4.0f32;
///
/// // (1/2)*2^3 -> 1 * 8/2 -> 4.0
/// let f = x.frexp();
/// let abs_difference_0 = (f.0 - 0.5).abs();
- /// let abs_difference_1 = (f.1 as f64 - 3.0).abs();
+ /// let abs_difference_1 = (f.1 as f32 - 3.0).abs();
///
- /// assert!(abs_difference_0 < 1e-10);
- /// assert!(abs_difference_1 < 1e-10);
+ /// assert!(abs_difference_0 <= f32::EPSILON);
+ /// assert!(abs_difference_1 <= f32::EPSILON);
/// ```
#[unstable(feature = "std_misc",
reason = "pending integer conventions")]
#[inline]
- pub fn frexp(self) -> (f32, int) {
+ pub fn frexp(self) -> (f32, isize) {
unsafe {
let mut exp = 0;
let x = cmath::frexpf(self, &mut exp);
- (x, exp as int)
+ (x, exp as isize)
}
}
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
/// let x = 1.0f32;
///
/// let abs_diff = (x.next_after(2.0) - 1.00000011920928955078125_f32).abs();
///
- /// assert!(abs_diff < 1e-10);
+ /// assert!(abs_diff <= f32::EPSILON);
/// ```
#[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
/// Returns the maximum of the two numbers.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 1.0;
- /// let y = 2.0;
+ /// let x = 1.0f32;
+ /// let y = 2.0f32;
///
/// assert_eq!(x.max(y), y);
/// ```
/// Returns the minimum of the two numbers.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 1.0;
- /// let y = 2.0;
+ /// let x = 1.0f32;
+ /// let y = 2.0f32;
///
/// assert_eq!(x.min(y), x);
/// ```
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 3.0;
- /// let y = -3.0;
+ /// let x = 3.0f32;
+ /// let y = -3.0f32;
///
/// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
/// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
///
- /// assert!(abs_difference_x < 1e-10);
- /// assert!(abs_difference_y < 1e-10);
+ /// assert!(abs_difference_x <= f32::EPSILON);
+ /// assert!(abs_difference_y <= f32::EPSILON);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn abs_sub(self, other: f32) -> f32 {
unsafe { cmath::fdimf(self, other) }
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 8.0;
+ /// let x = 8.0f32;
///
/// // x^(1/3) - 2 == 0
/// let abs_difference = (x.cbrt() - 2.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn cbrt(self) -> f32 {
unsafe { cmath::cbrtf(self) }
/// legs of length `x` and `y`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 2.0;
- /// let y = 3.0;
+ /// let x = 2.0f32;
+ /// let y = 3.0f32;
///
/// // sqrt(x^2 + y^2)
/// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn hypot(self, other: f32) -> f32 {
unsafe { cmath::hypotf(self, other) }
/// Computes the sine of a number (in radians).
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let x = f64::consts::PI/2.0;
+ /// let x = f32::consts::PI/2.0;
///
/// let abs_difference = (x.sin() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Computes the cosine of a number (in radians).
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let x = 2.0*f64::consts::PI;
+ /// let x = 2.0*f32::consts::PI;
///
/// let abs_difference = (x.cos() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Computes the tangent of a number (in radians).
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let x = f64::consts::PI/4.0;
/// let abs_difference = (x.tan() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-14);
+ /// assert!(abs_difference < 1e-10);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// [-1, 1].
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let f = f64::consts::PI / 2.0;
+ /// let f = f32::consts::PI / 2.0;
///
/// // asin(sin(pi/2))
- /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs();
+ /// let abs_difference = f.sin().asin().abs_sub(f32::consts::PI / 2.0);
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// [-1, 1].
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let f = f64::consts::PI / 4.0;
+ /// let f = f32::consts::PI / 4.0;
///
/// // acos(cos(pi/4))
- /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs();
+ /// let abs_difference = f.cos().acos().abs_sub(f32::consts::PI / 4.0);
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// range [-pi/2, pi/2];
///
/// ```
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let f = 1.0;
+ /// let f = 1.0f32;
///
/// // atan(tan(1))
- /// let abs_difference = (f.tan().atan() - 1.0).abs();
+ /// let abs_difference = f.tan().atan().abs_sub(1.0);
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let pi = f64::consts::PI;
+ /// let pi = f32::consts::PI;
/// // All angles from horizontal right (+x)
/// // 45 deg counter-clockwise
- /// let x1 = 3.0;
- /// let y1 = -3.0;
+ /// let x1 = 3.0f32;
+ /// let y1 = -3.0f32;
///
/// // 135 deg clockwise
- /// let x2 = -3.0;
- /// let y2 = 3.0;
+ /// let x2 = -3.0f32;
+ /// let y2 = 3.0f32;
///
/// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
/// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
///
- /// assert!(abs_difference_1 < 1e-10);
- /// assert!(abs_difference_2 < 1e-10);
+ /// assert!(abs_difference_1 <= f32::EPSILON);
+ /// assert!(abs_difference_2 <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// `(sin(x), cos(x))`.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let x = f64::consts::PI/4.0;
+ /// let x = f32::consts::PI/4.0;
/// let f = x.sin_cos();
///
/// let abs_difference_0 = (f.0 - x.sin()).abs();
/// let abs_difference_1 = (f.1 - x.cos()).abs();
///
- /// assert!(abs_difference_0 < 1e-10);
- /// assert!(abs_difference_0 < 1e-10);
+ /// assert!(abs_difference_0 <= f32::EPSILON);
+ /// assert!(abs_difference_0 <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// number is close to zero.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
+ /// use std::f64;
///
- /// let x = 7.0;
+ /// let x = 7.0f64;
///
/// // e^(ln(7)) - 1
- /// let abs_difference = (x.ln().exp_m1() - 6.0).abs();
+ /// let abs_difference = x.ln().exp_m1().abs_sub(6.0);
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn exp_m1(self) -> f32 {
unsafe { cmath::expm1f(self) }
/// the operations were performed separately.
///
/// ```
- /// # #![feature(std_misc, core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let x = f64::consts::E - 1.0;
+ /// let x = f32::consts::E - 1.0;
///
/// // ln(1 + (e - 1)) == ln(e) == 1
/// let abs_difference = (x.ln_1p() - 1.0).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn ln_1p(self) -> f32 {
unsafe { cmath::log1pf(self) }
/// Hyperbolic sine function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let e = f64::consts::E;
- /// let x = 1.0;
+ /// let e = f32::consts::E;
+ /// let x = 1.0f32;
///
/// let f = x.sinh();
/// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
/// let g = (e*e - 1.0)/(2.0*e);
/// let abs_difference = (f - g).abs();
///
- /// assert!(abs_difference < 1e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Hyperbolic cosine function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let e = f64::consts::E;
- /// let x = 1.0;
+ /// let e = f32::consts::E;
+ /// let x = 1.0f32;
/// let f = x.cosh();
/// // Solving cosh() at 1 gives this result
/// let g = (e*e + 1.0)/(2.0*e);
- /// let abs_difference = (f - g).abs();
+ /// let abs_difference = f.abs_sub(g);
///
/// // Same result
- /// assert!(abs_difference < 1.0e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Hyperbolic tangent function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let e = f64::consts::E;
- /// let x = 1.0;
+ /// let e = f32::consts::E;
+ /// let x = 1.0f32;
///
/// let f = x.tanh();
/// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
/// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));
/// let abs_difference = (f - g).abs();
///
- /// assert!(abs_difference < 1.0e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Inverse hyperbolic sine function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 1.0;
+ /// let x = 1.0f32;
/// let f = x.sinh().asinh();
///
/// let abs_difference = (f - x).abs();
///
- /// assert!(abs_difference < 1.0e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Inverse hyperbolic cosine function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
+ /// use std::f32;
///
- /// let x = 1.0;
+ /// let x = 1.0f32;
/// let f = x.cosh().acosh();
///
/// let abs_difference = (f - x).abs();
///
- /// assert!(abs_difference < 1.0e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// Inverse hyperbolic tangent function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
- /// use std::f64;
+ /// use std::f32;
///
- /// let e = f64::consts::E;
+ /// let e = f32::consts::E;
/// let f = e.tanh().atanh();
///
- /// let abs_difference = (f - e).abs();
+ /// let abs_difference = f.abs_sub(e);
///
- /// assert!(abs_difference < 1.0e-10);
+ /// assert!(abs_difference <= f32::EPSILON);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// * num - The float value
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[deprecated(since = "1.0.0", reason = "use the ToString trait instead")]
pub fn to_string(num: f32) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigAll, ExpNone, false);
/// * num - The float value
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[deprecated(since = "1.0.0", reason = "use format! instead")]
pub fn to_str_hex(num: f32) -> String {
let (r, _) = strconv::float_to_str_common(
num, 16, true, SignNeg, DigAll, ExpNone, false);
/// * radix - The base to use
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[deprecated(since = "1.0.0", reason = "use format! instead")]
pub fn to_str_radix_special(num: f32, rdx: u32) -> (String, bool) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
}
/// * digits - The number of significant digits
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_exact(num: f32, dig: uint) -> String {
+pub fn to_str_exact(num: f32, dig: usize) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigExact(dig), ExpNone, false);
r
/// * digits - The number of significant digits
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_digits(num: f32, dig: uint) -> String {
+pub fn to_str_digits(num: f32, dig: usize) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigMax(dig), ExpNone, false);
r
/// * upper - Use `E` instead of `e` for the exponent sign
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String {
+pub fn to_str_exp_exact(num: f32, dig: usize, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigExact(dig), ExpDec, upper);
r
/// * upper - Use `E` instead of `e` for the exponent sign
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String {
+pub fn to_str_exp_digits(num: f32, dig: usize, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigMax(dig), ExpDec, upper);
r
assert!(!nan.is_infinite());
assert!(!nan.is_finite());
assert!(!nan.is_normal());
- assert!(!nan.is_positive());
- assert!(!nan.is_negative());
+ assert!(!nan.is_sign_positive());
+ assert!(!nan.is_sign_negative());
assert_eq!(Fp::Nan, nan.classify());
}
let inf: f32 = Float::infinity();
assert!(inf.is_infinite());
assert!(!inf.is_finite());
- assert!(inf.is_positive());
- assert!(!inf.is_negative());
+ assert!(inf.is_sign_positive());
+ assert!(!inf.is_sign_negative());
assert!(!inf.is_nan());
assert!(!inf.is_normal());
assert_eq!(Fp::Infinite, inf.classify());
let neg_inf: f32 = Float::neg_infinity();
assert!(neg_inf.is_infinite());
assert!(!neg_inf.is_finite());
- assert!(!neg_inf.is_positive());
- assert!(neg_inf.is_negative());
+ assert!(!neg_inf.is_sign_positive());
+ assert!(neg_inf.is_sign_negative());
assert!(!neg_inf.is_nan());
assert!(!neg_inf.is_normal());
assert_eq!(Fp::Infinite, neg_inf.classify());
assert_eq!(0.0, zero);
assert!(!zero.is_infinite());
assert!(zero.is_finite());
- assert!(zero.is_positive());
- assert!(!zero.is_negative());
+ assert!(zero.is_sign_positive());
+ assert!(!zero.is_sign_negative());
assert!(!zero.is_nan());
assert!(!zero.is_normal());
assert_eq!(Fp::Zero, zero.classify());
assert_eq!(0.0, neg_zero);
assert!(!neg_zero.is_infinite());
assert!(neg_zero.is_finite());
- assert!(!neg_zero.is_positive());
- assert!(neg_zero.is_negative());
+ assert!(!neg_zero.is_sign_positive());
+ assert!(neg_zero.is_sign_negative());
assert!(!neg_zero.is_nan());
assert!(!neg_zero.is_normal());
assert_eq!(Fp::Zero, neg_zero.classify());
assert_eq!(1.0, one);
assert!(!one.is_infinite());
assert!(one.is_finite());
- assert!(one.is_positive());
- assert!(!one.is_negative());
+ assert!(one.is_sign_positive());
+ assert!(!one.is_sign_negative());
assert!(!one.is_nan());
assert!(one.is_normal());
assert_eq!(Fp::Normal, one.classify());
}
#[test]
- fn test_is_positive() {
- assert!(INFINITY.is_positive());
- assert!(1f32.is_positive());
- assert!(0f32.is_positive());
- assert!(!(-0f32).is_positive());
- assert!(!(-1f32).is_positive());
- assert!(!NEG_INFINITY.is_positive());
- assert!(!(1f32/NEG_INFINITY).is_positive());
- assert!(!NAN.is_positive());
+ fn test_is_sign_positive() {
+ assert!(INFINITY.is_sign_positive());
+ assert!(1f32.is_sign_positive());
+ assert!(0f32.is_sign_positive());
+ assert!(!(-0f32).is_sign_positive());
+ assert!(!(-1f32).is_sign_positive());
+ assert!(!NEG_INFINITY.is_sign_positive());
+ assert!(!(1f32/NEG_INFINITY).is_sign_positive());
+ assert!(!NAN.is_sign_positive());
}
#[test]
- fn test_is_negative() {
- assert!(!INFINITY.is_negative());
- assert!(!1f32.is_negative());
- assert!(!0f32.is_negative());
- assert!((-0f32).is_negative());
- assert!((-1f32).is_negative());
- assert!(NEG_INFINITY.is_negative());
- assert!((1f32/NEG_INFINITY).is_negative());
- assert!(!NAN.is_negative());
+ fn test_is_sign_negative() {
+ assert!(!INFINITY.is_sign_negative());
+ assert!(!1f32.is_sign_negative());
+ assert!(!0f32.is_sign_negative());
+ assert!((-0f32).is_sign_negative());
+ assert!((-1f32).is_sign_negative());
+ assert!(NEG_INFINITY.is_sign_negative());
+ assert!((1f32/NEG_INFINITY).is_sign_negative());
+ assert!(!NAN.is_sign_negative());
}
#[test]
}
#[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
impl Float for f64 {
// inlined methods from `num::Float`
#[inline]
#[allow(deprecated)]
#[inline]
- fn mantissa_digits(unused_self: Option<f64>) -> uint {
+ fn mantissa_digits(unused_self: Option<f64>) -> usize {
num::Float::mantissa_digits(unused_self)
}
#[allow(deprecated)]
#[inline]
- fn digits(unused_self: Option<f64>) -> uint { num::Float::digits(unused_self) }
+ fn digits(unused_self: Option<f64>) -> usize { num::Float::digits(unused_self) }
#[allow(deprecated)]
#[inline]
fn epsilon() -> f64 { num::Float::epsilon() }
#[allow(deprecated)]
#[inline]
- fn min_exp(unused_self: Option<f64>) -> int { num::Float::min_exp(unused_self) }
+ fn min_exp(unused_self: Option<f64>) -> isize { num::Float::min_exp(unused_self) }
#[allow(deprecated)]
#[inline]
- fn max_exp(unused_self: Option<f64>) -> int { num::Float::max_exp(unused_self) }
+ fn max_exp(unused_self: Option<f64>) -> isize { num::Float::max_exp(unused_self) }
#[allow(deprecated)]
#[inline]
- fn min_10_exp(unused_self: Option<f64>) -> int { num::Float::min_10_exp(unused_self) }
+ fn min_10_exp(unused_self: Option<f64>) -> isize { num::Float::min_10_exp(unused_self) }
#[allow(deprecated)]
#[inline]
- fn max_10_exp(unused_self: Option<f64>) -> int { num::Float::max_10_exp(unused_self) }
+ fn max_10_exp(unused_self: Option<f64>) -> isize { num::Float::max_10_exp(unused_self) }
#[allow(deprecated)]
#[inline]
fn min_value() -> f64 { num::Float::min_value() }
/// - `self = x * pow(2, exp)`
/// - `0.5 <= abs(x) < 1.0`
#[inline]
- fn frexp(self) -> (f64, int) {
+ fn frexp(self) -> (f64, isize) {
unsafe {
let mut exp = 0;
let x = cmath::frexp(self, &mut exp);
- (x, exp as int)
+ (x, exp as isize)
}
}
#[lang = "f64"]
#[stable(feature = "rust1", since = "1.0.0")]
impl f64 {
- // inlined methods from `num::Float`
- /// Returns the `NaN` value.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let nan: f32 = Float::nan();
- ///
- /// assert!(nan.is_nan());
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn nan() -> f64 { num::Float::nan() }
-
- /// Returns the infinite value.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f32;
- ///
- /// let infinity: f32 = Float::infinity();
- ///
- /// assert!(infinity.is_infinite());
- /// assert!(!infinity.is_finite());
- /// assert!(infinity > f32::MAX);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn infinity() -> f64 { num::Float::infinity() }
-
- /// Returns the negative infinite value.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f32;
- ///
- /// let neg_infinity: f32 = Float::neg_infinity();
- ///
- /// assert!(neg_infinity.is_infinite());
- /// assert!(!neg_infinity.is_finite());
- /// assert!(neg_infinity < f32::MIN);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn neg_infinity() -> f64 { num::Float::neg_infinity() }
-
- /// Returns `0.0`.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let inf: f32 = Float::infinity();
- /// let zero: f32 = Float::zero();
- /// let neg_zero: f32 = Float::neg_zero();
- ///
- /// assert_eq!(zero, neg_zero);
- /// assert_eq!(7.0f32/inf, zero);
- /// assert_eq!(zero * 10.0, zero);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn zero() -> f64 { num::Float::zero() }
-
- /// Returns `-0.0`.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let inf: f32 = Float::infinity();
- /// let zero: f32 = Float::zero();
- /// let neg_zero: f32 = Float::neg_zero();
- ///
- /// assert_eq!(zero, neg_zero);
- /// assert_eq!(7.0f32/inf, zero);
- /// assert_eq!(zero * 10.0, zero);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn neg_zero() -> f64 { num::Float::neg_zero() }
-
- /// Returns `1.0`.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let one: f32 = Float::one();
- ///
- /// assert_eq!(one, 1.0f32);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- pub fn one() -> f64 { num::Float::one() }
-
- // FIXME (#5527): These should be associated constants
-
- /// Deprecated: use `std::f32::MANTISSA_DIGITS` or `std::f64::MANTISSA_DIGITS`
- /// instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MANTISSA_DIGITS` or \
- `std::f64::MANTISSA_DIGITS` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn mantissa_digits(unused_self: Option<f64>) -> uint {
- num::Float::mantissa_digits(unused_self)
- }
-
- /// Deprecated: use `std::f32::DIGITS` or `std::f64::DIGITS` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn digits(unused_self: Option<f64>) -> uint { num::Float::digits(unused_self) }
-
- /// Deprecated: use `std::f32::EPSILON` or `std::f64::EPSILON` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::EPSILON` or `std::f64::EPSILON` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn epsilon() -> f64 { num::Float::epsilon() }
-
- /// Deprecated: use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn min_exp(unused_self: Option<f64>) -> int { num::Float::min_exp(unused_self) }
-
- /// Deprecated: use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn max_exp(unused_self: Option<f64>) -> int { num::Float::max_exp(unused_self) }
-
- /// Deprecated: use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn min_10_exp(unused_self: Option<f64>) -> int { num::Float::min_10_exp(unused_self) }
-
- /// Deprecated: use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` instead.
- #[unstable(feature = "std_misc")]
- #[deprecated(since = "1.0.0",
- reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")]
- #[allow(deprecated)]
- #[inline]
- pub fn max_10_exp(unused_self: Option<f64>) -> int { num::Float::max_10_exp(unused_self) }
-
- /// Returns the smallest finite value that this type can represent.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::min_value();
- ///
- /// assert_eq!(x, f64::MIN);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- #[allow(deprecated)]
- pub fn min_value() -> f64 { num::Float::min_value() }
-
- /// Returns the smallest normalized positive number that this type can represent.
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- #[allow(deprecated)]
- pub fn min_pos_value(unused_self: Option<f64>) -> f64 { num::Float::min_pos_value(unused_self) }
-
- /// Returns the largest finite value that this type can represent.
- ///
- /// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f64;
- ///
- /// let x: f64 = Float::max_value();
- /// assert_eq!(x, f64::MAX);
- /// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
- #[inline]
- #[allow(deprecated)]
- pub fn max_value() -> f64 { num::Float::max_value() }
-
/// Returns `true` if this value is `NaN` and false otherwise.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
/// use std::f64;
///
/// let nan = f64::NAN;
- /// let f = 7.0;
+ /// let f = 7.0_f64;
///
/// assert!(nan.is_nan());
/// assert!(!f.is_nan());
/// ```
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_nan(self) -> bool { num::Float::is_nan(self) }
/// false otherwise.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f32;
+ /// use std::f64;
///
- /// let f = 7.0f32;
- /// let inf: f32 = Float::infinity();
- /// let neg_inf: f32 = Float::neg_infinity();
- /// let nan: f32 = f32::NAN;
+ /// let f = 7.0f64;
+ /// let inf = f64::INFINITY;
+ /// let neg_inf = f64::NEG_INFINITY;
+ /// let nan = f64::NAN;
///
/// assert!(!f.is_infinite());
/// assert!(!nan.is_infinite());
/// assert!(inf.is_infinite());
/// assert!(neg_inf.is_infinite());
/// ```
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_infinite(self) -> bool { num::Float::is_infinite(self) }
/// Returns `true` if this number is neither infinite nor `NaN`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- /// use std::f32;
+ /// use std::f64;
///
- /// let f = 7.0f32;
- /// let inf: f32 = Float::infinity();
- /// let neg_inf: f32 = Float::neg_infinity();
- /// let nan: f32 = f32::NAN;
+ /// let f = 7.0f64;
+ /// let inf: f64 = f64::INFINITY;
+ /// let neg_inf: f64 = f64::NEG_INFINITY;
+ /// let nan: f64 = f64::NAN;
///
/// assert!(f.is_finite());
///
/// assert!(!inf.is_finite());
/// assert!(!neg_inf.is_finite());
/// ```
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_finite(self) -> bool { num::Float::is_finite(self) }
/// [subnormal][subnormal], or `NaN`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
/// use std::f32;
///
- /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
+ /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f64
/// let max = f32::MAX;
/// let lower_than_min = 1.0e-40_f32;
/// let zero = 0.0f32;
/// assert!(!lower_than_min.is_normal());
/// ```
/// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number
- #[unstable(feature = "std_misc", reason = "position is undecided")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_normal(self) -> bool { num::Float::is_normal(self) }
/// predicate instead.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::{Float, FpCategory};
- /// use std::f32;
+ /// use std::num::FpCategory;
+ /// use std::f64;
///
- /// let num = 12.4f32;
- /// let inf = f32::INFINITY;
+ /// let num = 12.4_f64;
+ /// let inf = f64::INFINITY;
///
/// assert_eq!(num.classify(), FpCategory::Normal);
/// assert_eq!(inf.classify(), FpCategory::Infinite);
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let num = 2.0f32;
+ /// let num = 2.0f64;
///
/// // (8388608, -22, 1)
/// let (mantissa, exponent, sign) = num.integer_decode();
- /// let sign_f = sign as f32;
- /// let mantissa_f = mantissa as f32;
- /// let exponent_f = num.powf(exponent as f32);
+ /// let sign_f = sign as f64;
+ /// let mantissa_f = mantissa as f64;
+ /// let exponent_f = num.powf(exponent as f64);
///
/// // 1 * 8388608 * 2^(-22) == 2
/// let abs_difference = (sign_f * mantissa_f * exponent_f - num).abs();
/// Returns the largest integer less than or equal to a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.99;
- /// let g = 3.0;
+ /// let f = 3.99_f64;
+ /// let g = 3.0_f64;
///
/// assert_eq!(f.floor(), 3.0);
/// assert_eq!(g.floor(), 3.0);
/// Returns the smallest integer greater than or equal to a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.01;
- /// let g = 4.0;
+ /// let f = 3.01_f64;
+ /// let g = 4.0_f64;
///
/// assert_eq!(f.ceil(), 4.0);
/// assert_eq!(g.ceil(), 4.0);
/// `0.0`.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.3;
- /// let g = -3.3;
+ /// let f = 3.3_f64;
+ /// let g = -3.3_f64;
///
/// assert_eq!(f.round(), 3.0);
/// assert_eq!(g.round(), -3.0);
/// Return the integer part of a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 3.3;
- /// let g = -3.7;
+ /// let f = 3.3_f64;
+ /// let g = -3.7_f64;
///
/// assert_eq!(f.trunc(), 3.0);
/// assert_eq!(g.trunc(), -3.0);
/// Returns the fractional part of a number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 3.5;
- /// let y = -3.5;
+ /// let x = 3.5_f64;
+ /// let y = -3.5_f64;
/// let abs_difference_x = (x.fract() - 0.5).abs();
/// let abs_difference_y = (y.fract() - (-0.5)).abs();
///
#[inline]
pub fn fract(self) -> f64 { num::Float::fract(self) }
- /// Computes the absolute value of `self`. Returns `Float::nan()` if the
- /// number is `Float::nan()`.
+ /// Computes the absolute value of `self`. Returns `NAN` if the
+ /// number is `NAN`.
///
/// ```
- /// # #![feature(core, std_misc)]
- /// use std::num::Float;
/// use std::f64;
///
- /// let x = 3.5;
- /// let y = -3.5;
+ /// let x = 3.5_f64;
+ /// let y = -3.5_f64;
///
/// let abs_difference_x = (x.abs() - x).abs();
/// let abs_difference_y = (y.abs() - (-y)).abs();
/// Returns a number that represents the sign of `self`.
///
- /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
- /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
- /// - `Float::nan()` if the number is `Float::nan()`
+ /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
+ /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
+ /// - `NAN` if the number is `NAN`
///
/// ```
- /// # #![feature(core, std_misc)]
- /// use std::num::Float;
/// use std::f64;
///
- /// let f = 3.5;
+ /// let f = 3.5_f64;
///
/// assert_eq!(f.signum(), 1.0);
/// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);
#[inline]
pub fn signum(self) -> f64 { num::Float::signum(self) }
- /// Returns `true` if `self` is positive, including `+0.0` and
- /// `Float::infinity()`.
+ /// Returns `true` if `self`'s sign bit is positive, including
+ /// `+0.0` and `INFINITY`.
///
/// ```
- /// use std::num::Float;
/// use std::f64;
///
/// let nan: f64 = f64::NAN;
///
- /// let f = 7.0;
- /// let g = -7.0;
+ /// let f = 7.0_f64;
+ /// let g = -7.0_f64;
///
- /// assert!(f.is_positive());
- /// assert!(!g.is_positive());
+ /// assert!(f.is_sign_positive());
+ /// assert!(!g.is_sign_positive());
/// // Requires both tests to determine if is `NaN`
- /// assert!(!nan.is_positive() && !nan.is_negative());
+ /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ pub fn is_sign_positive(self) -> bool { num::Float::is_positive(self) }
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to is_sign_positive")]
+ #[inline]
pub fn is_positive(self) -> bool { num::Float::is_positive(self) }
- /// Returns `true` if `self` is negative, including `-0.0` and
- /// `Float::neg_infinity()`.
+ /// Returns `true` if `self`'s sign is negative, including `-0.0`
+ /// and `NEG_INFINITY`.
///
/// ```
- /// use std::num::Float;
/// use std::f64;
///
/// let nan = f64::NAN;
///
- /// let f = 7.0;
- /// let g = -7.0;
+ /// let f = 7.0_f64;
+ /// let g = -7.0_f64;
///
- /// assert!(!f.is_negative());
- /// assert!(g.is_negative());
+ /// assert!(!f.is_sign_negative());
+ /// assert!(g.is_sign_negative());
/// // Requires both tests to determine if is `NaN`.
- /// assert!(!nan.is_positive() && !nan.is_negative());
+ /// assert!(!nan.is_sign_positive() && !nan.is_sign_negative());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
+ pub fn is_sign_negative(self) -> bool { num::Float::is_negative(self) }
+
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[deprecated(since = "1.0.0", reason = "renamed to is_sign_negative")]
+ #[inline]
pub fn is_negative(self) -> bool { num::Float::is_negative(self) }
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
/// a separate multiplication operation followed by an add.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let m = 10.0;
- /// let x = 4.0;
- /// let b = 60.0;
+ /// let m = 10.0_f64;
+ /// let x = 4.0_f64;
+ /// let b = 60.0_f64;
///
/// // 100.0
/// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn mul_add(self, a: f64, b: f64) -> f64 { num::Float::mul_add(self, a, b) }
/// Take the reciprocal (inverse) of a number, `1/x`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let x = 2.0;
+ /// let x = 2.0_f64;
/// let abs_difference = (x.recip() - (1.0/x)).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn recip(self) -> f64 { num::Float::recip(self) }
/// Using this function is generally faster than using `powf`
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 2.0;
+ /// let x = 2.0_f64;
/// let abs_difference = (x.powi(2) - x*x).abs();
///
/// assert!(abs_difference < 1e-10);
/// Raise a number to a floating point power.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 2.0;
+ /// let x = 2.0_f64;
/// let abs_difference = (x.powf(2.0) - x*x).abs();
///
/// assert!(abs_difference < 1e-10);
/// Returns NaN if `self` is a negative number.
///
/// ```
- /// # #![feature(core, std_misc)]
- /// use std::num::Float;
- ///
- /// let positive = 4.0;
- /// let negative = -4.0;
+ /// let positive = 4.0_f64;
+ /// let negative = -4.0_f64;
///
/// let abs_difference = (positive.sqrt() - 2.0).abs();
///
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let f = 4.0;
+ /// let f = 4.0_f64;
///
/// let abs_difference = (f.rsqrt() - 0.5).abs();
///
/// ```
#[unstable(feature = "std_misc",
reason = "unsure about its place in the world")]
+ #[deprecated(since = "1.0.0", reason = "use self.sqrt().recip() instead")]
#[inline]
pub fn rsqrt(self) -> f64 { num::Float::rsqrt(self) }
/// Returns `e^(self)`, (the exponential function).
///
/// ```
- /// use std::num::Float;
- ///
- /// let one = 1.0;
+ /// let one = 1.0_f64;
/// // e^1
/// let e = one.exp();
///
/// Returns `2^(self)`.
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 2.0;
+ /// let f = 2.0_f64;
///
/// // 2^2 - 4 == 0
/// let abs_difference = (f.exp2() - 4.0).abs();
/// Returns the natural logarithm of the number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let one = 1.0;
+ /// let one = 1.0_f64;
/// // e^1
/// let e = one.exp();
///
/// Returns the logarithm of the number with respect to an arbitrary base.
///
/// ```
- /// use std::num::Float;
- ///
- /// let ten = 10.0;
- /// let two = 2.0;
+ /// let ten = 10.0_f64;
+ /// let two = 2.0_f64;
///
/// // log10(10) - 1 == 0
/// let abs_difference_10 = (ten.log(10.0) - 1.0).abs();
/// Returns the base 2 logarithm of the number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let two = 2.0;
+ /// let two = 2.0_f64;
///
/// // log2(2) - 1 == 0
/// let abs_difference = (two.log2() - 1.0).abs();
/// Returns the base 10 logarithm of the number.
///
/// ```
- /// use std::num::Float;
- ///
- /// let ten = 10.0;
+ /// let ten = 10.0_f64;
///
/// // log10(10) - 1 == 0
/// let abs_difference = (ten.log10() - 1.0).abs();
/// Convert radians to degrees.
///
/// ```
- /// # #![feature(std_misc, core)]
- /// use std::num::Float;
/// use std::f64::consts;
///
/// let angle = consts::PI;
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "desirability is unclear")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn to_degrees(self) -> f64 { num::Float::to_degrees(self) }
/// Convert degrees to radians.
///
/// ```
- /// # #![feature(std_misc, core)]
- /// use std::num::Float;
/// use std::f64::consts;
///
- /// let angle = 180.0;
+ /// let angle = 180.0_f64;
///
/// let abs_difference = (angle.to_radians() - consts::PI).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "desirability is unclear")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn to_radians(self) -> f64 { num::Float::to_radians(self) }
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
/// // 3*2^2 - 12 == 0
- /// let abs_difference = (Float::ldexp(3.0, 2) - 12.0).abs();
+ /// let abs_difference = (f64::ldexp(3.0, 2) - 12.0).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
#[unstable(feature = "std_misc",
reason = "pending integer conventions")]
#[inline]
- pub fn ldexp(x: f64, exp: int) -> f64 {
+ pub fn ldexp(x: f64, exp: isize) -> f64 {
unsafe { cmath::ldexp(x, exp as c_int) }
}
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let x = 4.0;
+ /// let x = 4.0_f64;
///
/// // (1/2)*2^3 -> 1 * 8/2 -> 4.0
/// let f = x.frexp();
#[unstable(feature = "std_misc",
reason = "pending integer conventions")]
#[inline]
- pub fn frexp(self) -> (f64, int) {
+ pub fn frexp(self) -> (f64, isize) {
unsafe {
let mut exp = 0;
let x = cmath::frexp(self, &mut exp);
- (x, exp as int)
+ (x, exp as isize)
}
}
///
/// ```
/// # #![feature(std_misc)]
- /// use std::num::Float;
///
/// let x = 1.0f32;
///
/// Returns the maximum of the two numbers.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 1.0;
- /// let y = 2.0;
+ /// let x = 1.0_f64;
+ /// let y = 2.0_f64;
///
/// assert_eq!(x.max(y), y);
/// ```
/// Returns the minimum of the two numbers.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 1.0;
- /// let y = 2.0;
+ /// let x = 1.0_f64;
+ /// let y = 2.0_f64;
///
/// assert_eq!(x.min(y), x);
/// ```
/// * Else: `self - other`
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let x = 3.0;
- /// let y = -3.0;
+ /// let x = 3.0_f64;
+ /// let y = -3.0_f64;
///
/// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
/// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
/// assert!(abs_difference_x < 1e-10);
/// assert!(abs_difference_y < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn abs_sub(self, other: f64) -> f64 {
unsafe { cmath::fdim(self, other) }
/// Take the cubic root of a number.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let x = 8.0;
+ /// let x = 8.0_f64;
///
/// // x^(1/3) - 2 == 0
/// let abs_difference = (x.cbrt() - 2.0).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn cbrt(self) -> f64 {
unsafe { cmath::cbrt(self) }
/// legs of length `x` and `y`.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let x = 2.0;
- /// let y = 3.0;
+ /// let x = 2.0_f64;
+ /// let y = 3.0_f64;
///
/// // sqrt(x^2 + y^2)
/// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc",
- reason = "unsure about its place in the world")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn hypot(self, other: f64) -> f64 {
unsafe { cmath::hypot(self, other) }
/// Computes the sine of a number (in radians).
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let x = f64::consts::PI/2.0;
/// Computes the cosine of a number (in radians).
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let x = 2.0*f64::consts::PI;
/// Computes the tangent of a number (in radians).
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let x = f64::consts::PI/4.0;
/// [-1, 1].
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let f = f64::consts::PI / 2.0;
/// [-1, 1].
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let f = f64::consts::PI / 4.0;
/// range [-pi/2, pi/2];
///
/// ```
- /// use std::num::Float;
- ///
- /// let f = 1.0;
+ /// let f = 1.0_f64;
///
/// // atan(tan(1))
/// let abs_difference = (f.tan().atan() - 1.0).abs();
/// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let pi = f64::consts::PI;
/// // All angles from horizontal right (+x)
/// // 45 deg counter-clockwise
- /// let x1 = 3.0;
- /// let y1 = -3.0;
+ /// let x1 = 3.0_f64;
+ /// let y1 = -3.0_f64;
///
/// // 135 deg clockwise
- /// let x2 = -3.0;
- /// let y2 = 3.0;
+ /// let x2 = -3.0_f64;
+ /// let y2 = 3.0_f64;
///
/// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
/// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
/// `(sin(x), cos(x))`.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let x = f64::consts::PI/4.0;
/// number is close to zero.
///
/// ```
- /// # #![feature(std_misc)]
- /// use std::num::Float;
- ///
- /// let x = 7.0;
+ /// let x = 7.0_f64;
///
/// // e^(ln(7)) - 1
/// let abs_difference = (x.ln().exp_m1() - 6.0).abs();
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn exp_m1(self) -> f64 {
unsafe { cmath::expm1(self) }
/// the operations were performed separately.
///
/// ```
- /// # #![feature(std_misc, core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let x = f64::consts::E - 1.0;
///
/// assert!(abs_difference < 1e-10);
/// ```
- #[unstable(feature = "std_misc", reason = "may be renamed")]
+ #[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn ln_1p(self) -> f64 {
unsafe { cmath::log1p(self) }
/// Hyperbolic sine function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let e = f64::consts::E;
- /// let x = 1.0;
+ /// let x = 1.0_f64;
///
/// let f = x.sinh();
/// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
/// Hyperbolic cosine function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let e = f64::consts::E;
- /// let x = 1.0;
+ /// let x = 1.0_f64;
/// let f = x.cosh();
/// // Solving cosh() at 1 gives this result
/// let g = (e*e + 1.0)/(2.0*e);
/// Hyperbolic tangent function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let e = f64::consts::E;
- /// let x = 1.0;
+ /// let x = 1.0_f64;
///
/// let f = x.tanh();
/// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
/// Inverse hyperbolic sine function.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 1.0;
+ /// let x = 1.0_f64;
/// let f = x.sinh().asinh();
///
/// let abs_difference = (f - x).abs();
/// Inverse hyperbolic cosine function.
///
/// ```
- /// use std::num::Float;
- ///
- /// let x = 1.0;
+ /// let x = 1.0_f64;
/// let f = x.cosh().acosh();
///
/// let abs_difference = (f - x).abs();
/// Inverse hyperbolic tangent function.
///
/// ```
- /// # #![feature(core)]
- /// use std::num::Float;
/// use std::f64;
///
/// let e = f64::consts::E;
/// * num - The float value
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[deprecated(since = "1.0.0", reason = "use the ToString trait instead")]
pub fn to_string(num: f64) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigAll, ExpNone, false);
/// * num - The float value
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[deprecated(since = "1.0.0", reason = "use format! instead")]
pub fn to_str_hex(num: f64) -> String {
let (r, _) = strconv::float_to_str_common(
num, 16, true, SignNeg, DigAll, ExpNone, false);
/// * radix - The base to use
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[deprecated(since = "1.0.0", reason = "use format! instead")]
pub fn to_str_radix_special(num: f64, rdx: u32) -> (String, bool) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
}
/// * digits - The number of significant digits
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_exact(num: f64, dig: uint) -> String {
+pub fn to_str_exact(num: f64, dig: usize) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigExact(dig), ExpNone, false);
r
/// * digits - The number of significant digits
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_digits(num: f64, dig: uint) -> String {
+pub fn to_str_digits(num: f64, dig: usize) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigMax(dig), ExpNone, false);
r
/// * upper - Use `E` instead of `e` for the exponent sign
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String {
+pub fn to_str_exp_exact(num: f64, dig: usize, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigExact(dig), ExpDec, upper);
r
/// * upper - Use `E` instead of `e` for the exponent sign
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String {
+pub fn to_str_exp_digits(num: f64, dig: usize, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
num, 10, true, SignNeg, DigMax(dig), ExpDec, upper);
r
assert!(!nan.is_infinite());
assert!(!nan.is_finite());
assert!(!nan.is_normal());
- assert!(!nan.is_positive());
- assert!(!nan.is_negative());
+ assert!(!nan.is_sign_positive());
+ assert!(!nan.is_sign_negative());
assert_eq!(Fp::Nan, nan.classify());
}
let inf: f64 = Float::infinity();
assert!(inf.is_infinite());
assert!(!inf.is_finite());
- assert!(inf.is_positive());
- assert!(!inf.is_negative());
+ assert!(inf.is_sign_positive());
+ assert!(!inf.is_sign_negative());
assert!(!inf.is_nan());
assert!(!inf.is_normal());
assert_eq!(Fp::Infinite, inf.classify());
let neg_inf: f64 = Float::neg_infinity();
assert!(neg_inf.is_infinite());
assert!(!neg_inf.is_finite());
- assert!(!neg_inf.is_positive());
- assert!(neg_inf.is_negative());
+ assert!(!neg_inf.is_sign_positive());
+ assert!(neg_inf.is_sign_negative());
assert!(!neg_inf.is_nan());
assert!(!neg_inf.is_normal());
assert_eq!(Fp::Infinite, neg_inf.classify());
assert_eq!(0.0, zero);
assert!(!zero.is_infinite());
assert!(zero.is_finite());
- assert!(zero.is_positive());
- assert!(!zero.is_negative());
+ assert!(zero.is_sign_positive());
+ assert!(!zero.is_sign_negative());
assert!(!zero.is_nan());
assert!(!zero.is_normal());
assert_eq!(Fp::Zero, zero.classify());
assert_eq!(0.0, neg_zero);
assert!(!neg_zero.is_infinite());
assert!(neg_zero.is_finite());
- assert!(!neg_zero.is_positive());
- assert!(neg_zero.is_negative());
+ assert!(!neg_zero.is_sign_positive());
+ assert!(neg_zero.is_sign_negative());
assert!(!neg_zero.is_nan());
assert!(!neg_zero.is_normal());
assert_eq!(Fp::Zero, neg_zero.classify());
assert_eq!(1.0, one);
assert!(!one.is_infinite());
assert!(one.is_finite());
- assert!(one.is_positive());
- assert!(!one.is_negative());
+ assert!(one.is_sign_positive());
+ assert!(!one.is_sign_negative());
assert!(!one.is_nan());
assert!(one.is_normal());
assert_eq!(Fp::Normal, one.classify());
}
#[test]
- fn test_is_positive() {
- assert!(INFINITY.is_positive());
- assert!(1f64.is_positive());
- assert!(0f64.is_positive());
- assert!(!(-0f64).is_positive());
- assert!(!(-1f64).is_positive());
- assert!(!NEG_INFINITY.is_positive());
- assert!(!(1f64/NEG_INFINITY).is_positive());
- assert!(!NAN.is_positive());
+ fn test_is_sign_positive() {
+ assert!(INFINITY.is_sign_positive());
+ assert!(1f64.is_sign_positive());
+ assert!(0f64.is_sign_positive());
+ assert!(!(-0f64).is_sign_positive());
+ assert!(!(-1f64).is_sign_positive());
+ assert!(!NEG_INFINITY.is_sign_positive());
+ assert!(!(1f64/NEG_INFINITY).is_sign_positive());
+ assert!(!NAN.is_sign_positive());
}
#[test]
- fn test_is_negative() {
- assert!(!INFINITY.is_negative());
- assert!(!1f64.is_negative());
- assert!(!0f64.is_negative());
- assert!((-0f64).is_negative());
- assert!((-1f64).is_negative());
- assert!(NEG_INFINITY.is_negative());
- assert!((1f64/NEG_INFINITY).is_negative());
- assert!(!NAN.is_negative());
+ fn test_is_sign_negative() {
+ assert!(!INFINITY.is_sign_negative());
+ assert!(!1f64.is_sign_negative());
+ assert!(!0f64.is_sign_negative());
+ assert!((-0f64).is_sign_negative());
+ assert!((-1f64).is_sign_negative());
+ assert!(NEG_INFINITY.is_sign_negative());
+ assert!((1f64/NEG_INFINITY).is_sign_negative());
+ assert!(!NAN.is_sign_negative());
}
#[test]
#![stable(feature = "rust1", since = "1.0.0")]
#![allow(missing_docs)]
+#![allow(deprecated)]
#[cfg(test)] use fmt::Debug;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
use clone::Clone;
use cmp::{PartialOrd, PartialEq};
-pub use core::num::{Int, SignedInt};
+pub use core::num::{Int, SignedInt, Zero, One};
pub use core::num::{cast, FromPrimitive, NumCast, ToPrimitive};
pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64};
pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64};
pub use core::num::{from_f32, from_f64};
pub use core::num::{FromStrRadix, from_str_radix};
pub use core::num::{FpCategory, ParseIntError, ParseFloatError};
-pub use core::num::wrapping;
+pub use core::num::{wrapping, Wrapping};
use option::Option;
-#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "likely to be removed")]
pub mod strconv;
/// Mathematical operations on primitive floating point numbers.
#[stable(feature = "rust1", since = "1.0.0")]
+#[deprecated(since = "1.0.0",
+ reason = "replaced by inherent methods; use rust-lang/num for generics")]
pub trait Float
: Copy + Clone
+ NumCast
/// ```
#[unstable(feature = "std_misc", reason = "position is undecided")]
fn is_finite(self) -> bool;
+
/// Returns `true` if the number is neither zero, infinite,
/// [subnormal][subnormal], or `NaN`.
///
#[cfg(test)]
mod tests {
- use prelude::v1::*;
+ use core::prelude::*;
use super::*;
use i8;
use i16;
use u32;
use u64;
use usize;
+ use string::ToString;
macro_rules! test_cast_20 {
($_20:expr) => ({
// ignore-lexer-test FIXME #15679
#![allow(missing_docs)]
+#![allow(deprecated)]
use self::ExponentFormat::*;
use self::SignificantDigits::*;
/// At most the given number of digits will be printed, truncating any
/// trailing zeroes.
- DigMax(uint),
+ DigMax(usize),
/// Precisely the given number of digits will be printed.
- DigExact(uint)
+ DigExact(usize)
}
/// How to emit the sign of a number.
/// # Panics
///
/// - Panics if `radix` < 2 or `radix` > 36.
-fn int_to_str_bytes_common<T, F>(num: T, radix: uint, sign: SignFormat, mut f: F) where
+fn int_to_str_bytes_common<T, F>(num: T, radix: usize, sign: SignFormat, mut f: F) where
T: Int,
F: FnMut(u8),
{
let neg = num < _0 || (negative_zero && _1 / num == Float::neg_infinity());
let mut buf = Vec::new();
- let radix_gen: T = num::cast(radix as int).unwrap();
+ let radix_gen: T = num::cast(radix as isize).unwrap();
let (num, exp) = match exp_format {
ExpNone => (num, 0),
let extra_digit = ascii2value(buf.pop().unwrap());
if extra_digit >= radix / 2 { // -> need to round
- let mut i: int = buf.len() as int - 1;
+ let mut i: isize = buf.len() as isize - 1;
loop {
// If reached left end of number, have to
// insert additional digit:
if i < 0
- || buf[i as uint] == b'-'
- || buf[i as uint] == b'+' {
- buf.insert((i + 1) as uint, value2ascii(1));
+ || buf[i as usize] == b'-'
+ || buf[i as usize] == b'+' {
+ buf.insert((i + 1) as usize, value2ascii(1));
break;
}
// Skip the '.'
- if buf[i as uint] == b'.' { i -= 1; continue; }
+ if buf[i as usize] == b'.' { i -= 1; continue; }
// Either increment the digit,
// or set to 0 if max and carry the 1.
- let current_digit = ascii2value(buf[i as uint]);
+ let current_digit = ascii2value(buf[i as usize]);
if current_digit < (radix - 1) {
- buf[i as uint] = value2ascii(current_digit+1);
+ buf[i as usize] = value2ascii(current_digit+1);
break;
} else {
- buf[i as uint] = value2ascii(0);
+ buf[i as usize] = value2ascii(0);
i -= 1;
}
}
#![allow(deprecated)] // rand
extern crate test;
- mod uint {
+ mod usize {
use super::test::Bencher;
use rand::{weak_rng, Rng};
use std::fmt;
#[inline]
- fn to_string(x: uint, base: u8) {
+ fn to_string(x: usize, base: u8) {
format!("{}", fmt::radix(x, base));
}
#[bench]
fn to_str_bin(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<uint>(), 2); })
+ b.iter(|| { to_string(rng.gen::<usize>(), 2); })
}
#[bench]
fn to_str_oct(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<uint>(), 8); })
+ b.iter(|| { to_string(rng.gen::<usize>(), 8); })
}
#[bench]
fn to_str_dec(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<uint>(), 10); })
+ b.iter(|| { to_string(rng.gen::<usize>(), 10); })
}
#[bench]
fn to_str_hex(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<uint>(), 16); })
+ b.iter(|| { to_string(rng.gen::<usize>(), 16); })
}
#[bench]
fn to_str_base_36(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<uint>(), 36); })
+ b.iter(|| { to_string(rng.gen::<usize>(), 36); })
}
}
- mod int {
+ mod isize {
use super::test::Bencher;
use rand::{weak_rng, Rng};
use std::fmt;
#[inline]
- fn to_string(x: int, base: u8) {
+ fn to_string(x: isize, base: u8) {
format!("{}", fmt::radix(x, base));
}
#[bench]
fn to_str_bin(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<int>(), 2); })
+ b.iter(|| { to_string(rng.gen::<isize>(), 2); })
}
#[bench]
fn to_str_oct(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<int>(), 8); })
+ b.iter(|| { to_string(rng.gen::<isize>(), 8); })
}
#[bench]
fn to_str_dec(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<int>(), 10); })
+ b.iter(|| { to_string(rng.gen::<isize>(), 10); })
}
#[bench]
fn to_str_hex(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<int>(), 16); })
+ b.iter(|| { to_string(rng.gen::<isize>(), 16); })
}
#[bench]
fn to_str_base_36(b: &mut Bencher) {
let mut rng = weak_rng();
- b.iter(|| { to_string(rng.gen::<int>(), 36); })
+ b.iter(|| { to_string(rng.gen::<isize>(), 36); })
}
}
use cmp;
use fmt;
use old_io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
-use iter::{IteratorExt, ExactSizeIterator, repeat};
+use iter::{Iterator, ExactSizeIterator, repeat};
use ops::Drop;
use option::Option;
use option::Option::{Some, None};
pub struct BufferedReader<R> {
inner: R,
buf: Vec<u8>,
- pos: uint,
- cap: uint,
+ pos: usize,
+ cap: usize,
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Reader> BufferedReader<R> {
/// Creates a new `BufferedReader` with the specified buffer capacity
- pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
+ pub fn with_capacity(cap: usize, inner: R) -> BufferedReader<R> {
BufferedReader {
inner: inner,
// We can't use the same trick here as we do for BufferedWriter,
Ok(&self.buf[self.pos..self.cap])
}
- fn consume(&mut self, amt: uint) {
+ fn consume(&mut self, amt: usize) {
self.pos += amt;
assert!(self.pos <= self.cap);
}
}
impl<R: Reader> Reader for BufferedReader<R> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
if self.pos == self.cap && buf.len() >= self.buf.len() {
return self.inner.read(buf);
}
let nread = {
let available = try!(self.fill_buf());
let nread = cmp::min(available.len(), buf.len());
- slice::bytes::copy_memory(buf, &available[..nread]);
+ slice::bytes::copy_memory(&available[..nread], buf);
nread
};
self.pos += nread;
pub struct BufferedWriter<W: Writer> {
inner: Option<W>,
buf: Vec<u8>,
- pos: uint
+ pos: usize
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Writer> BufferedWriter<W> {
/// Creates a new `BufferedWriter` with the specified buffer capacity
- pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
+ pub fn with_capacity(cap: usize, inner: W) -> BufferedWriter<W> {
// It's *much* faster to create an uninitialized buffer than it is to
// fill everything in with 0. This buffer is entirely an implementation
// detail and is never exposed, so we're safe to not initialize
self.inner.as_mut().unwrap().write_all(buf)
} else {
let dst = &mut self.buf[self.pos..];
- slice::bytes::copy_memory(dst, buf);
+ slice::bytes::copy_memory(buf, dst);
self.pos += buf.len();
Ok(())
}
}
impl<W: Reader + Writer> Reader for InternalBufferedWriter<W> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.get_mut().inner.as_mut().unwrap().read(buf)
}
}
impl<S: Stream> BufferedStream<S> {
/// Creates a new buffered stream with explicitly listed capacities for the
/// reader/writer buffer.
- pub fn with_capacities(reader_cap: uint, writer_cap: uint, inner: S)
+ pub fn with_capacities(reader_cap: usize, writer_cap: usize, inner: S)
-> BufferedStream<S> {
let writer = BufferedWriter::with_capacity(writer_cap, inner);
let internal_writer = InternalBufferedWriter(writer);
impl<S: Stream> Buffer for BufferedStream<S> {
fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> { self.inner.fill_buf() }
- fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
+ fn consume(&mut self, amt: usize) { self.inner.consume(amt) }
}
impl<S: Stream> Reader for BufferedStream<S> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.inner.read(buf)
}
}
pub struct NullStream;
impl Reader for NullStream {
- fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<usize> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
/// A dummy reader intended at testing short-reads propagation.
pub struct ShortReader {
- lengths: Vec<uint>,
+ lengths: Vec<usize>,
}
impl Reader for ShortReader {
- fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<usize> {
if self.lengths.is_empty() {
Err(old_io::standard_error(old_io::EndOfFile))
} else {
writer.write_all(&[0, 1]).unwrap();
let b: &[_] = &[];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.write_all(&[2]).unwrap();
let b: &[_] = &[0, 1];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.write_all(&[3]).unwrap();
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.flush().unwrap();
let a: &[_] = &[0, 1, 2, 3];
- assert_eq!(a, &writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[..]);
writer.write_all(&[4]).unwrap();
writer.write_all(&[5]).unwrap();
- assert_eq!(a, &writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[..]);
writer.write_all(&[6]).unwrap();
let a: &[_] = &[0, 1, 2, 3, 4, 5];
- assert_eq!(a, &writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[..]);
writer.write_all(&[7, 8]).unwrap();
let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
- assert_eq!(a, &writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[..]);
writer.write_all(&[9, 10, 11]).unwrap();
let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
- assert_eq!(a, &writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[..]);
writer.flush().unwrap();
- assert_eq!(a, &writer.get_ref()[]);
+ assert_eq!(a, &writer.get_ref()[..]);
}
#[test]
let mut w = BufferedWriter::with_capacity(3, Vec::new());
w.write_all(&[0, 1]).unwrap();
let a: &[_] = &[];
- assert_eq!(a, &w.get_ref()[]);
+ assert_eq!(a, &w.get_ref()[..]);
let w = w.into_inner();
let a: &[_] = &[0, 1];
assert_eq!(a, &w[..]);
}
impl old_io::Reader for S {
- fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<usize> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
let mut writer = LineBufferedWriter::new(Vec::new());
writer.write_all(&[0]).unwrap();
let b: &[_] = &[];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.write_all(&[1]).unwrap();
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.flush().unwrap();
let b: &[_] = &[0, 1];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.write_all(&[0, b'\n', 1, b'\n', 2]).unwrap();
let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.flush().unwrap();
let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
writer.write_all(&[3, b'\n']).unwrap();
let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
- assert_eq!(&writer.get_ref()[], b);
+ assert_eq!(&writer.get_ref()[..], b);
}
#[test]
/// ```
pub struct ChanReader {
buf: Vec<u8>, // A buffer of bytes received but not consumed.
- pos: uint, // How many of the buffered bytes have already be consumed.
+ pos: usize, // How many of the buffered bytes have already be consumed.
rx: Receiver<Vec<u8>>, // The Receiver to pull data from.
closed: bool, // Whether the channel this Receiver connects to has been closed.
}
}
}
- fn consume(&mut self, amt: uint) {
+ fn consume(&mut self, amt: usize) {
self.pos += amt;
assert!(self.pos <= self.buf.len());
}
}
impl Reader for ChanReader {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let mut num_read = 0;
loop {
let count = match self.fill_buf().ok() {
Some(src) => {
let dst = &mut buf[num_read..];
let count = cmp::min(src.len(), dst.len());
- bytes::copy_memory(dst, &src[..count]);
+ bytes::copy_memory(&src[..count], dst);
count
},
None => 0,
/// * `f`: A callback that receives the value.
///
/// This function returns the value returned by the callback, for convenience.
-pub fn u64_to_le_bytes<T, F>(n: u64, size: uint, f: F) -> T where
+pub fn u64_to_le_bytes<T, F>(n: u64, size: usize, f: F) -> T where
F: FnOnce(&[u8]) -> T,
{
use mem::transmute;
/// * `f`: A callback that receives the value.
///
/// This function returns the value returned by the callback, for convenience.
-pub fn u64_to_be_bytes<T, F>(n: u64, size: uint, f: F) -> T where
+pub fn u64_to_be_bytes<T, F>(n: u64, size: usize, f: F) -> T where
F: FnOnce(&[u8]) -> T,
{
use mem::transmute;
/// less, or task panic occurs. If this is less than 8, then only
/// that many bytes are parsed. For example, if `size` is 4, then a
/// 32-bit value is parsed.
-pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
+pub fn u64_from_be_bytes(data: &[u8], start: usize, size: usize) -> u64 {
use ptr::{copy_nonoverlapping};
assert!(size <= 8);
let mut buf = [0; 8];
unsafe {
- let ptr = data.as_ptr().offset(start as int);
+ let ptr = data.as_ptr().offset(start as isize);
let out = buf.as_mut_ptr();
- copy_nonoverlapping(out.offset((8 - size) as int), ptr, size);
+ copy_nonoverlapping(ptr, out.offset((8 - size) as isize), size);
(*(out as *const u64)).to_be()
}
}
use old_io::{MemReader, BytesReader};
struct InitialZeroByteReader {
- count: int,
+ count: isize,
}
impl Reader for InitialZeroByteReader {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
if self.count == 0 {
self.count = 1;
Ok(0)
struct EofReader;
impl Reader for EofReader {
- fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<usize> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
struct ErroringReader;
impl Reader for ErroringReader {
- fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, _: &mut [u8]) -> old_io::IoResult<usize> {
Err(old_io::standard_error(old_io::InvalidInput))
}
}
struct PartialReader {
- count: int,
+ count: isize,
}
impl Reader for PartialReader {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
if self.count == 0 {
self.count = 1;
buf[0] = 10;
}
struct ErroringLaterReader {
- count: int,
+ count: isize,
}
impl Reader for ErroringLaterReader {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
if self.count == 0 {
self.count = 1;
buf[0] = 10;
}
struct ThreeChunkReader {
- count: int,
+ count: isize,
}
impl Reader for ThreeChunkReader {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
if self.count == 0 {
self.count = 1;
buf[0] = 10;
pub struct File {
fd: fs_imp::FileDesc,
path: Path,
- last_nread: int,
+ last_nread: isize,
}
impl sys_common::AsInner<fs_imp::FileDesc> for File {
///
/// # Examples
///
- /// ```rust,should_fail
+ /// ```rust,should_panic
/// # #![feature(old_io, old_path)]
/// use std::old_io::*;
/// use std::old_path::Path;
#[deprecated(since = "1.0.0", reason = "replaced with std::fs::set_permissions")]
#[unstable(feature = "old_io")]
pub fn chmod(path: &Path, mode: old_io::FilePermission) -> IoResult<()> {
- fs_imp::chmod(path, mode.bits() as uint)
+ fs_imp::chmod(path, mode.bits() as usize)
.update_err("couldn't chmod path", |e|
format!("{}; path={}; mode={:?}", e, path.display(), mode))
}
/// Change the user and group owners of a file at the specified path.
#[unstable(feature = "old_fs")]
-pub fn chown(path: &Path, uid: int, gid: int) -> IoResult<()> {
+pub fn chown(path: &Path, uid: isize, gid: isize) -> IoResult<()> {
fs_imp::chown(path, uid, gid)
.update_err("couldn't chown path", |e|
format!("{}; path={}; uid={}; gid={}", e, path.display(), uid, gid))
/// new directory at the provided `path`, or if the directory already exists.
#[unstable(feature = "old_fs")]
pub fn mkdir(path: &Path, mode: FilePermission) -> IoResult<()> {
- fs_imp::mkdir(path, mode.bits() as uint)
+ fs_imp::mkdir(path, mode.bits() as usize)
.update_err("couldn't create directory", |e|
format!("{}; path={}; mode={}", e, path.display(), mode))
}
}
impl Reader for File {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
fn update_err<T>(result: IoResult<T>, file: &File) -> IoResult<T> {
result.update_err("couldn't read file",
|e| format!("{}; path={}",
match result {
Ok(read) => {
- self.last_nread = read as int;
+ self.last_nread = read as isize;
match read {
0 => update_err(Err(standard_error(old_io::EndOfFile)), self),
- _ => Ok(read as uint)
+ _ => Ok(read as usize)
}
},
Err(e) => Err(e)
let stem = f.filestem_str().unwrap();
let root = stem.as_bytes()[0] - b'0';
let name = stem.as_bytes()[1] - b'0';
- assert!(cur[root as uint] < name);
- cur[root as uint] = name;
+ assert!(cur[root as usize] < name);
+ cur[root as usize] = name;
}
check!(rmdir_recursive(dir));
b"foobar\0\0\0\0".to_vec());
// Truncate to a smaller length, don't seek, and then write something.
- // Ensure that the intermediate zeroes are all filled in (we're seeked
+ // Ensure that the intermediate zeroes are all filled in (we have `seek`ed
// past the end of the file).
check!(file.truncate(2));
assert_eq!(check!(file.stat()).size, 2);
use slice;
use vec::Vec;
-const BUF_CAPACITY: uint = 128;
+const BUF_CAPACITY: usize = 128;
-fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
+fn combine(seek: SeekStyle, cur: usize, end: usize, offset: i64) -> IoResult<u64> {
// compute offset as signed and clamp to prevent overflow
let pos = match seek {
old_io::SeekSet => 0,
/// Create a new `MemWriter`, allocating at least `n` bytes for
/// the internal buffer.
#[inline]
- pub fn with_capacity(n: uint) -> MemWriter {
+ pub fn with_capacity(n: usize) -> MemWriter {
MemWriter::from_vec(Vec::with_capacity(n))
}
/// Create a new `MemWriter` that will append to an existing `Vec`.
/// ```
pub struct MemReader {
buf: Vec<u8>,
- pos: uint
+ pos: usize
}
impl MemReader {
impl Reader for MemReader {
#[inline]
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
let write_len = min(buf.len(), self.buf.len() - self.pos);
let input = &self.buf[self.pos.. self.pos + write_len];
let output = &mut buf[..write_len];
assert_eq!(input.len(), output.len());
- slice::bytes::copy_memory(output, input);
+ slice::bytes::copy_memory(input, output);
}
self.pos += write_len;
assert!(self.pos <= self.buf.len());
#[inline]
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = try!(combine(style, self.pos, self.buf.len(), pos));
- self.pos = new as uint;
+ self.pos = new as usize;
Ok(())
}
}
}
#[inline]
- fn consume(&mut self, amt: uint) { self.pos += amt; }
+ fn consume(&mut self, amt: usize) { self.pos += amt; }
}
impl<'a> Reader for &'a [u8] {
#[inline]
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
if self.is_empty() { return Err(old_io::standard_error(old_io::EndOfFile)); }
let write_len = min(buf.len(), self.len());
{
let input = &self[..write_len];
let output = &mut buf[.. write_len];
- slice::bytes::copy_memory(output, input);
+ slice::bytes::copy_memory(input, output);
}
*self = &self[write_len..];
}
#[inline]
- fn consume(&mut self, amt: uint) {
+ fn consume(&mut self, amt: usize) {
*self = &self[amt..];
}
}
/// ```
pub struct BufWriter<'a> {
buf: &'a mut [u8],
- pos: uint
+ pos: usize
}
impl<'a> BufWriter<'a> {
let src_len = src.len();
if dst_len >= src_len {
- slice::bytes::copy_memory(dst, src);
+ slice::bytes::copy_memory(src, dst);
self.pos += src_len;
Ok(())
} else {
- slice::bytes::copy_memory(dst, &src[..dst_len]);
+ slice::bytes::copy_memory(&src[..dst_len], dst);
self.pos += dst_len;
#[inline]
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = try!(combine(style, self.pos, self.buf.len(), pos));
- self.pos = min(new as uint, self.buf.len());
+ self.pos = min(new as usize, self.buf.len());
Ok(())
}
}
/// ```
pub struct BufReader<'a> {
buf: &'a [u8],
- pos: uint
+ pos: usize
}
impl<'a> BufReader<'a> {
impl<'a> Reader for BufReader<'a> {
#[inline]
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
let write_len = min(buf.len(), self.buf.len() - self.pos);
let input = &self.buf[self.pos.. self.pos + write_len];
let output = &mut buf[..write_len];
assert_eq!(input.len(), output.len());
- slice::bytes::copy_memory(output, input);
+ slice::bytes::copy_memory(input, output);
}
self.pos += write_len;
assert!(self.pos <= self.buf.len());
#[inline]
fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
let new = try!(combine(style, self.pos, self.buf.len(), pos));
- self.pos = new as uint;
+ self.pos = new as usize;
Ok(())
}
}
}
#[inline]
- fn consume(&mut self, amt: uint) { self.pos += amt; }
+ fn consume(&mut self, amt: usize) { self.pos += amt; }
}
#[cfg(test)]
mod test {
- extern crate "test" as test_crate;
+ extern crate test as test_crate;
use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek, Buffer};
use prelude::v1::{Ok, Err, Vec, AsSlice};
- use prelude::v1::IteratorExt;
+ use prelude::v1::Iterator;
use old_io;
use iter::repeat;
use self::test_crate::Bencher;
assert_eq!(buf, b);
}
- fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
+ fn do_bench_mem_writer(b: &mut Bencher, times: usize, len: usize) {
let src: Vec<u8> = repeat(5).take(len).collect();
b.bytes = (times * len) as u64;
use error::Error;
use fmt;
use isize;
-use iter::{Iterator, IteratorExt};
+use iter::Iterator;
use marker::{PhantomFn, Sized};
use mem::transmute;
use ops::FnOnce;
/// The default buffer size for various I/O operations
// libuv recommends 64k buffers to maximize throughput
// https://groups.google.com/forum/#!topic/libuv/oQO1HJAIDdA
-const DEFAULT_BUF_SIZE: uint = 1024 * 64;
+const DEFAULT_BUF_SIZE: usize = 1024 * 64;
/// A convenient typedef of the return value of any I/O action.
pub type IoResult<T> = Result<T, IoError>;
///
/// The payload contained as part of this variant is the number of bytes
/// which are known to have been successfully written.
- ShortWrite(uint),
+ ShortWrite(usize),
/// The Reader returned 0 bytes from `read()` too many times.
NoProgress,
}
}
}
-static NO_PROGRESS_LIMIT: uint = 1000;
+static NO_PROGRESS_LIMIT: usize = 1000;
/// A trait for objects which are byte-oriented streams. Readers are defined by
/// one method, `read`. This function will block until data is available,
///
/// When implementing this method on a new Reader, you are strongly encouraged
/// not to return 0 if you can avoid it.
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint>;
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize>;
// Convenient helper methods based on the above methods
///
/// If an error occurs at any point, that error is returned, and no further
/// bytes are read.
- fn read_at_least(&mut self, min: uint, buf: &mut [u8]) -> IoResult<uint> {
+ fn read_at_least(&mut self, min: usize, buf: &mut [u8]) -> IoResult<usize> {
if min > buf.len() {
return Err(IoError {
detail: Some(String::from_str("the buffer is too short")),
///
/// If an error occurs during this I/O operation, then it is returned
/// as `Err(IoError)`. See `read()` for more details.
- fn push(&mut self, len: uint, buf: &mut Vec<u8>) -> IoResult<uint> {
+ fn push(&mut self, len: usize, buf: &mut Vec<u8>) -> IoResult<usize> {
let start_len = buf.len();
buf.reserve(len);
///
/// If an error occurs at any point, that error is returned, and no further
/// bytes are read.
- fn push_at_least(&mut self, min: uint, len: uint, buf: &mut Vec<u8>) -> IoResult<uint> {
+ fn push_at_least(&mut self, min: usize, len: usize, buf: &mut Vec<u8>) -> IoResult<usize> {
if min > len {
return Err(IoError {
detail: Some(String::from_str("the buffer is too short")),
/// have already been consumed from the underlying reader, and they are lost
/// (not returned as part of the error). If this is unacceptable, then it is
/// recommended to use the `push_at_least` or `read` methods.
- fn read_exact(&mut self, len: uint) -> IoResult<Vec<u8>> {
+ fn read_exact(&mut self, len: usize) -> IoResult<Vec<u8>> {
let mut buf = Vec::with_capacity(len);
match self.push_at_least(len, len, &mut buf) {
Ok(_) => Ok(buf),
/// Reads `n` little-endian unsigned integer bytes.
///
/// `n` must be between 1 and 8, inclusive.
- fn read_le_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
+ fn read_le_uint_n(&mut self, nbytes: usize) -> IoResult<u64> {
assert!(nbytes > 0 && nbytes <= 8);
let mut val = 0;
/// Reads `n` little-endian signed integer bytes.
///
/// `n` must be between 1 and 8, inclusive.
- fn read_le_int_n(&mut self, nbytes: uint) -> IoResult<i64> {
+ fn read_le_int_n(&mut self, nbytes: usize) -> IoResult<i64> {
self.read_le_uint_n(nbytes).map(|i| extend_sign(i, nbytes))
}
/// Reads `n` big-endian unsigned integer bytes.
///
/// `n` must be between 1 and 8, inclusive.
- fn read_be_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
+ fn read_be_uint_n(&mut self, nbytes: usize) -> IoResult<u64> {
assert!(nbytes > 0 && nbytes <= 8);
let mut val = 0;
/// Reads `n` big-endian signed integer bytes.
///
/// `n` must be between 1 and 8, inclusive.
- fn read_be_int_n(&mut self, nbytes: uint) -> IoResult<i64> {
+ fn read_be_int_n(&mut self, nbytes: usize) -> IoResult<i64> {
self.read_be_uint_n(nbytes).map(|i| extend_sign(i, nbytes))
}
/// Reads a little-endian unsigned integer.
///
/// The number of bytes returned is system-dependent.
- fn read_le_uint(&mut self) -> IoResult<uint> {
- self.read_le_uint_n(usize::BYTES as usize).map(|i| i as uint)
+ fn read_le_uint(&mut self) -> IoResult<usize> {
+ self.read_le_uint_n(usize::BYTES as usize).map(|i| i as usize)
}
/// Reads a little-endian integer.
///
/// The number of bytes returned is system-dependent.
- fn read_le_int(&mut self) -> IoResult<int> {
- self.read_le_int_n(isize::BYTES as usize).map(|i| i as int)
+ fn read_le_int(&mut self) -> IoResult<isize> {
+ self.read_le_int_n(isize::BYTES as usize).map(|i| i as isize)
}
/// Reads a big-endian unsigned integer.
///
/// The number of bytes returned is system-dependent.
- fn read_be_uint(&mut self) -> IoResult<uint> {
- self.read_be_uint_n(usize::BYTES as usize).map(|i| i as uint)
+ fn read_be_uint(&mut self) -> IoResult<usize> {
+ self.read_be_uint_n(usize::BYTES as usize).map(|i| i as usize)
}
/// Reads a big-endian integer.
///
/// The number of bytes returned is system-dependent.
- fn read_be_int(&mut self) -> IoResult<int> {
- self.read_be_int_n(isize::BYTES as usize).map(|i| i as int)
+ fn read_be_int(&mut self) -> IoResult<isize> {
+ self.read_be_int_n(isize::BYTES as usize).map(|i| i as isize)
}
/// Reads a big-endian `u64`.
}
impl<'a> Reader for Box<Reader+'a> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let reader: &mut Reader = &mut **self;
reader.read(buf)
}
}
impl<'a> Reader for &'a mut (Reader+'a) {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { (*self).read(buf) }
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> { (*self).read(buf) }
}
/// Returns a slice of `v` between `start` and `end`.
/// `start` > `end`.
// Private function here because we aren't sure if we want to expose this as
// API yet. If so, it should be a method on Vec.
-unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -> &'a mut [T] {
+unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: usize, end: usize) -> &'a mut [T] {
use slice;
assert!(start <= end);
assert!(end <= v.capacity());
slice::from_raw_parts_mut(
- v.as_mut_ptr().offset(start as int),
+ v.as_mut_ptr().offset(start as isize),
end - start
)
}
}
impl<'a, R: Reader> Reader for RefReader<'a, R> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> { self.inner.read(buf) }
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> { self.inner.read(buf) }
}
impl<'a, R: Buffer> Buffer for RefReader<'a, R> {
fn fill_buf(&mut self) -> IoResult<&[u8]> { self.inner.fill_buf() }
- fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
+ fn consume(&mut self, amt: usize) { self.inner.consume(amt) }
}
-fn extend_sign(val: u64, nbytes: uint) -> i64 {
+fn extend_sign(val: u64, nbytes: usize) -> i64 {
let shift = (8 - nbytes) * 8;
(val << shift) as i64 >> shift
}
self.write_all(&buf[..n])
}
- /// Write the result of passing n through `int::to_str_bytes`.
+ /// Write the result of passing n through `isize::to_str_bytes`.
#[inline]
- fn write_int(&mut self, n: int) -> IoResult<()> {
+ fn write_int(&mut self, n: isize) -> IoResult<()> {
write!(self, "{}", n)
}
- /// Write the result of passing n through `uint::to_str_bytes`.
+ /// Write the result of passing n through `usize::to_str_bytes`.
#[inline]
- fn write_uint(&mut self, n: uint) -> IoResult<()> {
+ fn write_uint(&mut self, n: usize) -> IoResult<()> {
write!(self, "{}", n)
}
- /// Write a little-endian uint (number of bytes depends on system).
+ /// Write a little-endian usize (number of bytes depends on system).
#[inline]
- fn write_le_uint(&mut self, n: uint) -> IoResult<()> {
+ fn write_le_uint(&mut self, n: usize) -> IoResult<()> {
extensions::u64_to_le_bytes(n as u64, usize::BYTES as usize, |v| self.write_all(v))
}
- /// Write a little-endian int (number of bytes depends on system).
+ /// Write a little-endian isize (number of bytes depends on system).
#[inline]
- fn write_le_int(&mut self, n: int) -> IoResult<()> {
+ fn write_le_int(&mut self, n: isize) -> IoResult<()> {
extensions::u64_to_le_bytes(n as u64, isize::BYTES as usize, |v| self.write_all(v))
}
- /// Write a big-endian uint (number of bytes depends on system).
+ /// Write a big-endian usize (number of bytes depends on system).
#[inline]
- fn write_be_uint(&mut self, n: uint) -> IoResult<()> {
+ fn write_be_uint(&mut self, n: usize) -> IoResult<()> {
extensions::u64_to_be_bytes(n as u64, usize::BYTES as usize, |v| self.write_all(v))
}
- /// Write a big-endian int (number of bytes depends on system).
+ /// Write a big-endian isize (number of bytes depends on system).
#[inline]
- fn write_be_int(&mut self, n: int) -> IoResult<()> {
+ fn write_be_int(&mut self, n: isize) -> IoResult<()> {
extensions::u64_to_be_bytes(n as u64, isize::BYTES as usize, |v| self.write_all(v))
}
/// Tells this buffer that `amt` bytes have been consumed from the buffer,
/// so they should no longer be returned in calls to `read`.
- fn consume(&mut self, amt: uint);
+ fn consume(&mut self, amt: usize);
/// Reads the next line of input, interpreted as a sequence of UTF-8
/// encoded Unicode codepoints. If a newline is encountered, then the
/// connections.
///
/// Doing so produces some sort of Acceptor.
-pub trait Listener<T, A: Acceptor<T>>
- : PhantomFn<T,T> // FIXME should be an assoc type anyhow
-{
+pub trait Listener<A: Acceptor> {
/// Spin up the listener and start queuing incoming connections
///
/// # Error
}
/// An acceptor is a value that presents incoming connections
-pub trait Acceptor<T> {
+pub trait Acceptor {
+ /// Type of connection that is accepted by this acceptor.
+ type Connection;
+
/// Wait for and accept an incoming connection
///
/// # Error
///
/// Returns `Err` if an I/O error is encountered.
- fn accept(&mut self) -> IoResult<T>;
+ fn accept(&mut self) -> IoResult<Self::Connection>;
/// Create an iterator over incoming connection attempts.
///
inc: &'a mut A,
}
-#[old_impl_check]
-impl<'a, T, A: ?Sized + Acceptor<T>> Iterator for IncomingConnections<'a, A> {
- type Item = IoResult<T>;
+impl<'a, A: ?Sized + Acceptor> Iterator for IncomingConnections<'a, A> {
+ type Item = IoResult<A::Connection>;
- fn next(&mut self) -> Option<IoResult<T>> {
+ fn next(&mut self) -> Option<IoResult<A::Connection>> {
Some(self.inc.accept())
}
}
#[derive(Clone, PartialEq, Debug)]
enum BadReaderBehavior {
- GoodBehavior(uint),
- BadBehavior(uint)
+ GoodBehavior(usize),
+ BadBehavior(usize)
}
struct BadReader<T> {
}
impl<T: Reader> Reader for BadReader<T> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let BadReader { ref mut behavior, ref mut r } = *self;
loop {
if behavior.is_empty() {
pub use self::Flag::*;
pub use self::Protocol::*;
-use iter::IteratorExt;
-use old_io::{IoResult};
+use iter::Iterator;
+use old_io::IoResult;
use old_io::net::ip::{SocketAddr, IpAddr};
use option::Option;
use option::Option::{Some, None};
/// `man -s 3 getaddrinfo`
#[derive(Copy, Debug)]
pub struct Hint {
- pub family: uint,
+ pub family: usize,
pub socktype: Option<SocketType>,
pub protocol: Option<Protocol>,
- pub flags: uint,
+ pub flags: usize,
}
#[derive(Copy, Debug)]
pub struct Info {
pub address: SocketAddr,
- pub family: uint,
+ pub family: usize,
pub socktype: Option<SocketType>,
pub protocol: Option<Protocol>,
- pub flags: uint,
+ pub flags: usize,
}
/// Easy name resolution. Given a hostname, returns the list of IP addresses for
use fmt;
use old_io::{self, IoResult, IoError};
use old_io::net;
-use iter::{Iterator, IteratorExt};
+use iter::Iterator;
use ops::{FnOnce, FnMut};
use option::Option;
use option::Option::{None, Some};
struct Parser<'a> {
// parsing as ASCII, so can use byte array
s: &'a [u8],
- pos: uint,
+ pos: usize,
}
impl<'a> Parser<'a> {
Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
}
- fn read_groups(p: &mut Parser, groups: &mut [u16; 8], limit: uint) -> (uint, bool) {
+ fn read_groups(p: &mut Parser, groups: &mut [u16; 8], limit: usize) -> (usize, bool) {
let mut i = 0;
while i < limit {
if i < limit - 1 {
}
impl Reader for UnixStream {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.inner.read(buf)
}
}
}
}
-impl Listener<UnixStream, UnixAcceptor> for UnixListener {
+impl Listener<UnixAcceptor> for UnixListener {
fn listen(self) -> IoResult<UnixAcceptor> {
self.inner.listen()
.map(|inner| UnixAcceptor { inner: inner })
}
}
-impl Acceptor<UnixStream> for UnixAcceptor {
+impl Acceptor for UnixAcceptor {
+ type Connection = UnixStream;
fn accept(&mut self) -> IoResult<UnixStream> {
self.inner.accept().map(|s| {
UnixStream { inner: s }
/// this connection. Otherwise, the keepalive timeout will be set to the
/// specified time, in seconds.
#[unstable(feature = "io")]
- pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> {
+ pub fn set_keepalive(&mut self, delay_in_seconds: Option<usize>) -> IoResult<()> {
self.inner.set_keepalive(delay_in_seconds)
}
}
impl Reader for TcpStream {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.inner.read(buf)
}
}
}
}
-impl Listener<TcpStream, TcpAcceptor> for TcpListener {
+impl Listener<TcpAcceptor> for TcpListener {
fn listen(self) -> IoResult<TcpAcceptor> {
self.inner.listen(128).map(|a| TcpAcceptor { inner: a })
}
}
}
-impl Acceptor<TcpStream> for TcpAcceptor {
+impl Acceptor for TcpAcceptor {
+ type Connection = TcpStream;
fn accept(&mut self) -> IoResult<TcpStream> {
self.inner.accept().map(TcpStream::new)
}
#[test]
fn multiple_connect_interleaved_greedy_schedule_ip4() {
let addr = next_test_ip4();
- static MAX: int = 10;
+ static MAX: isize = 10;
let acceptor = TcpListener::bind(addr).listen();
let _t = thread::spawn(move|| {
let mut acceptor = acceptor;
- for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
+ for (i, stream) in acceptor.incoming().enumerate().take(MAX as usize) {
// Start another task to handle the connection
let _t = thread::spawn(move|| {
let mut stream = stream;
connect(0, addr);
- fn connect(i: int, addr: SocketAddr) {
+ fn connect(i: isize, addr: SocketAddr) {
if i == MAX { return }
let _t = thread::spawn(move|| {
#[test]
fn multiple_connect_interleaved_greedy_schedule_ip6() {
let addr = next_test_ip6();
- static MAX: int = 10;
+ static MAX: isize = 10;
let acceptor = TcpListener::bind(addr).listen();
let _t = thread::spawn(move|| {
let mut acceptor = acceptor;
- for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
+ for (i, stream) in acceptor.incoming().enumerate().take(MAX as usize) {
// Start another task to handle the connection
let _t = thread::spawn(move|| {
let mut stream = stream;
connect(0, addr);
- fn connect(i: int, addr: SocketAddr) {
+ fn connect(i: isize, addr: SocketAddr) {
if i == MAX { return }
let _t = thread::spawn(move|| {
#[test]
fn multiple_connect_interleaved_lazy_schedule_ip4() {
- static MAX: int = 10;
+ static MAX: isize = 10;
let addr = next_test_ip4();
let acceptor = TcpListener::bind(addr).listen();
let _t = thread::spawn(move|| {
let mut acceptor = acceptor;
- for stream in acceptor.incoming().take(MAX as uint) {
+ for stream in acceptor.incoming().take(MAX as usize) {
// Start another task to handle the connection
let _t = thread::spawn(move|| {
let mut stream = stream;
connect(0, addr);
- fn connect(i: int, addr: SocketAddr) {
+ fn connect(i: isize, addr: SocketAddr) {
if i == MAX { return }
let _t = thread::spawn(move|| {
#[test]
fn multiple_connect_interleaved_lazy_schedule_ip6() {
- static MAX: int = 10;
+ static MAX: isize = 10;
let addr = next_test_ip6();
let acceptor = TcpListener::bind(addr).listen();
let _t = thread::spawn(move|| {
let mut acceptor = acceptor;
- for stream in acceptor.incoming().take(MAX as uint) {
+ for stream in acceptor.incoming().take(MAX as usize) {
// Start another task to handle the connection
let _t = thread::spawn(move|| {
let mut stream = stream;
connect(0, addr);
- fn connect(i: int, addr: SocketAddr) {
+ fn connect(i: isize, addr: SocketAddr) {
if i == MAX { return }
let _t = thread::spawn(move|| {
/// Receives data from the socket. On success, returns the number of bytes
/// read and the address from whence the data came.
- pub fn recv_from(&mut self, buf: &mut [u8]) -> IoResult<(uint, SocketAddr)> {
+ pub fn recv_from(&mut self, buf: &mut [u8]) -> IoResult<(usize, SocketAddr)> {
self.inner.recv_from(buf)
}
/// Sets the multicast TTL
#[unstable(feature = "io")]
- pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> {
+ pub fn set_multicast_ttl(&mut self, ttl: isize) -> IoResult<()> {
self.inner.multicast_time_to_live(ttl)
}
/// Sets this socket's TTL
#[unstable(feature = "io")]
- pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> {
+ pub fn set_ttl(&mut self, ttl: isize) -> IoResult<()> {
self.inner.time_to_live(ttl)
}
}
impl Reader for PipeStream {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.inner.read(buf)
}
}
/// Signal a process to exit, without forcibly killing it. Corresponds to
/// SIGTERM on unix platforms.
-#[cfg(windows)] pub const PleaseExitSignal: int = 15;
+#[cfg(windows)] pub const PleaseExitSignal: isize = 15;
/// Signal a process to exit immediately, forcibly killing it. Corresponds to
/// SIGKILL on unix platforms.
-#[cfg(windows)] pub const MustDieSignal: int = 9;
+#[cfg(windows)] pub const MustDieSignal: isize = 9;
/// Signal a process to exit, without forcibly killing it. Corresponds to
/// SIGTERM on unix platforms.
-#[cfg(not(windows))] pub const PleaseExitSignal: int = libc::SIGTERM as int;
+#[cfg(not(windows))] pub const PleaseExitSignal: isize = libc::SIGTERM as isize;
/// Signal a process to exit immediately, forcibly killing it. Corresponds to
/// SIGKILL on unix platforms.
-#[cfg(not(windows))] pub const MustDieSignal: int = libc::SIGKILL as int;
+#[cfg(not(windows))] pub const MustDieSignal: isize = libc::SIGKILL as isize;
/// Representation of a running or exited child process.
///
///
/// # Examples
///
-/// ```should_fail
+/// ```should_panic
/// # #![feature(old_io)]
/// use std::old_io::*;
///
exit_code: Option<ProcessExit>,
/// Manually delivered signal
- exit_signal: Option<int>,
+ exit_signal: Option<isize>,
/// Deadline after which wait() will return
deadline: u64,
stdin: StdioContainer,
stdout: StdioContainer,
stderr: StdioContainer,
- uid: Option<uint>,
- gid: Option<uint>,
+ uid: Option<usize>,
+ gid: Option<usize>,
detach: bool,
}
/// the child process. Setting this value on windows will cause the spawn to
/// fail. Failure in the `setuid` call on unix will also cause the spawn to
/// fail.
- pub fn uid<'a>(&'a mut self, id: uint) -> &'a mut Command {
+ pub fn uid<'a>(&'a mut self, id: usize) -> &'a mut Command {
self.uid = Some(id);
self
}
/// Similar to `uid`, but sets the group id of the child process. This has
/// the same semantics as the `uid` field.
- pub fn gid<'a>(&'a mut self, id: uint) -> &'a mut Command {
+ pub fn gid<'a>(&'a mut self, id: usize) -> &'a mut Command {
self.gid = Some(id);
self
}
fn cwd(&self) -> Option<&CString> {
self.cwd.as_ref()
}
- fn uid(&self) -> Option<uint> {
+ fn uid(&self) -> Option<usize> {
self.uid.clone()
}
- fn gid(&self) -> Option<uint> {
+ fn gid(&self) -> Option<usize> {
self.gid.clone()
}
fn detach(&self) -> bool {
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
pub enum ProcessExit {
/// Normal termination with an exit status.
- ExitStatus(int),
+ ExitStatus(isize),
/// Termination by signal, with the signal number.
- ExitSignal(int),
+ ExitSignal(isize),
}
#[stable(feature = "rust1", since = "1.0.0")]
/// Checks whether this ProcessExit matches the given exit status.
/// Termination by signal will never match an exit code.
- pub fn matches_exit_status(&self, wanted: int) -> bool {
+ pub fn matches_exit_status(&self, wanted: isize) -> bool {
*self == ExitStatus(wanted)
}
}
/// process. Note, though, that on some platforms signals will continue to
/// be successfully delivered if the child has exited, but not yet been
/// reaped.
- pub fn kill(id: libc::pid_t, signal: int) -> IoResult<()> {
+ pub fn kill(id: libc::pid_t, signal: isize) -> IoResult<()> {
unsafe { ProcessImp::killpid(id, signal) }
}
/// # Errors
///
/// If the signal delivery fails, the corresponding error is returned.
- pub fn signal(&mut self, signal: int) -> IoResult<()> {
+ pub fn signal(&mut self, signal: isize) -> IoResult<()> {
#[cfg(unix)] fn collect_status(p: &mut Process) {
// On Linux (and possibly other unices), a process that has exited will
// continue to accept signals because it is "defunct". The delivery of
use libc;
let mut p = Command::new("/bin/sh")
.arg("-c").arg("true")
- .uid(unsafe { libc::getuid() as uint })
- .gid(unsafe { libc::getgid() as uint })
+ .uid(unsafe { libc::getuid() as usize })
+ .gid(unsafe { libc::getgid() as usize })
.spawn().unwrap();
assert!(p.wait().unwrap().success());
}
}
impl<R: Reader> Reader for IoResult<R> {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
match *self {
Ok(ref mut reader) => reader.read(buf),
Err(ref e) => Err(e.clone()),
}
}
-impl<T, A: Acceptor<T>, L: Listener<T, A>> Listener<T, A> for IoResult<L> {
+impl<A: Acceptor, L: Listener<A>> Listener<A> for IoResult<L> {
fn listen(self) -> IoResult<A> {
match self {
Ok(listener) => listener.listen(),
}
}
-impl<T, A: Acceptor<T>> Acceptor<T> for IoResult<A> {
- fn accept(&mut self) -> IoResult<T> {
+impl<A: Acceptor> Acceptor for IoResult<A> {
+ type Connection = A::Connection;
+ fn accept(&mut self) -> IoResult<A::Connection> {
match *self {
Ok(ref mut acceptor) => acceptor.accept(),
Err(ref e) => Err(e.clone()),
}
impl Reader for StdinReader {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.inner.lock().unwrap().0.read(buf)
}
// read more than once and we don't want those calls to interleave (or
// incur the costs of repeated locking).
- fn read_at_least(&mut self, min: uint, buf: &mut [u8]) -> IoResult<uint> {
+ fn read_at_least(&mut self, min: usize, buf: &mut [u8]) -> IoResult<usize> {
self.inner.lock().unwrap().0.read_at_least(min, buf)
}
- fn push_at_least(&mut self, min: uint, len: uint, buf: &mut Vec<u8>) -> IoResult<uint> {
+ fn push_at_least(&mut self, min: usize, len: usize, buf: &mut Vec<u8>) -> IoResult<usize> {
self.inner.lock().unwrap().0.push_at_least(min, len, buf)
}
self.inner.lock().unwrap().0.read_to_end()
}
- fn read_le_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
+ fn read_le_uint_n(&mut self, nbytes: usize) -> IoResult<u64> {
self.inner.lock().unwrap().0.read_le_uint_n(nbytes)
}
- fn read_be_uint_n(&mut self, nbytes: uint) -> IoResult<u64> {
+ fn read_be_uint_n(&mut self, nbytes: usize) -> IoResult<u64> {
self.inner.lock().unwrap().0.read_be_uint_n(nbytes)
}
}
}
impl Reader for StdReader {
- fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let ret = match self.inner {
TTY(ref mut tty) => {
// Flush the task-local stdout so that weird issues like a
// print!'d prompt not being shown until after the user hits
// enter.
flush();
- tty.read(buf).map(|i| i as uint)
+ tty.read(buf).map(|i| i as usize)
},
- File(ref mut file) => file.read(buf).map(|i| i as uint),
+ File(ref mut file) => file.read(buf).map(|i| i as usize),
};
match ret {
// When reading a piped stdin, libuv will return 0-length reads when
///
/// This function will return an error if the output stream is not actually
/// connected to a TTY instance, or if querying the TTY instance fails.
- pub fn winsize(&mut self) -> IoResult<(int, int)> {
+ pub fn winsize(&mut self) -> IoResult<(isize, isize)> {
match self.inner {
TTY(ref mut tty) => {
tty.get_winsize()
#![allow(deprecated)] // rand
use env;
-use iter::{IteratorExt};
+use iter::Iterator;
use old_io::{fs, IoError, IoErrorKind, IoResult};
use old_io;
use ops::Drop;
// be enough to dissuade an attacker from trying to preemptively create names
// of that length, but not so huge that we unnecessarily drain the random number
// generator of entropy.
-const NUM_RAND_CHARS: uint = 12;
+const NUM_RAND_CHARS: usize = 12;
impl TempDir {
/// Attempts to make a temporary directory inside of `tmpdir` whose name
#[deprecated(since = "1.0.0", reason = "use std::io::Take")]
#[unstable(feature = "old_io")]
pub struct LimitReader<R> {
- limit: uint,
+ limit: usize,
inner: R
}
/// Creates a new `LimitReader`
#[deprecated(since = "1.0.0", reason = "use std::io's take method instead")]
#[unstable(feature = "old_io")]
- pub fn new(r: R, limit: uint) -> LimitReader<R> {
+ pub fn new(r: R, limit: usize) -> LimitReader<R> {
LimitReader { limit: limit, inner: r }
}
///
/// The reader may reach EOF after reading fewer bytes than indicated by
/// this method if the underlying reader reaches EOF.
- pub fn limit(&self) -> uint { self.limit }
+ pub fn limit(&self) -> usize { self.limit }
}
#[deprecated(since = "1.0.0", reason = "use std::io's take method instead")]
#[unstable(feature = "old_io")]
impl<R: Reader> Reader for LimitReader<R> {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
if self.limit == 0 {
return Err(old_io::standard_error(old_io::EndOfFile));
}
}
}
- fn consume(&mut self, amt: uint) {
+ fn consume(&mut self, amt: usize) {
// Don't let callers reset the limit by passing an overlarge value
let amt = cmp::min(amt, self.limit);
self.limit -= amt;
#[unstable(feature = "old_io")]
impl Reader for ZeroReader {
#[inline]
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
buf.set_memory(0);
Ok(buf.len())
}
Ok(&DATA)
}
- fn consume(&mut self, _amt: uint) {}
+ fn consume(&mut self, _amt: usize) {}
}
/// A `Reader` which is always at EOF, like /dev/null.
#[unstable(feature = "old_io")]
impl Reader for NullReader {
#[inline]
- fn read(&mut self, _buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, _buf: &mut [u8]) -> old_io::IoResult<usize> {
Err(old_io::standard_error(old_io::EndOfFile))
}
}
fn fill_buf<'a>(&'a mut self) -> old_io::IoResult<&'a [u8]> {
Err(old_io::standard_error(old_io::EndOfFile))
}
- fn consume(&mut self, _amt: uint) {}
+ fn consume(&mut self, _amt: usize) {}
}
/// A `Writer` which multiplexes writes to a set of `Writer`s.
#[deprecated(since = "1.0.0", reason = "use std::io::Chain instead")]
#[unstable(feature = "old_io")]
impl<R: Reader, I: Iterator<Item=R>> Reader for ChainedReader<I, R> {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
loop {
let err = match self.cur_reader {
Some(ref mut r) => {
#[deprecated(since = "1.0.0", reason = "use std::io::Tee instead")]
#[unstable(feature = "old_io")]
impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
self.reader.read(buf).and_then(|len| {
self.writer.write_all(&mut buf[..len]).map(|()| len)
})
impl<T: Iterator<Item=u8>> Reader for IterReader<T> {
#[inline]
- fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<uint> {
+ fn read(&mut self, buf: &mut [u8]) -> old_io::IoResult<usize> {
let mut len = 0;
for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) {
*slot = elt;
#[test]
fn test_multi_writer() {
- static mut writes: uint = 0;
- static mut flushes: uint = 0;
+ static mut writes: usize = 0;
+ static mut flushes: usize = 0;
struct TestWriter;
impl Writer for TestWriter {
use ffi::CString;
use clone::Clone;
use fmt;
-use iter::IteratorExt;
+use iter::Iterator;
use option::Option;
use option::Option::{None, Some};
use str;
use hash;
use old_io::Writer;
use iter::{AdditiveIterator, Extend};
-use iter::{Iterator, IteratorExt, Map};
+use iter::{Iterator, Map};
use marker::Sized;
use option::Option::{self, Some, None};
use result::Result::{self, Ok, Err};
#[derive(Clone)]
pub struct Path {
repr: Vec<u8>, // assumed to never be empty or contain NULs
- sepidx: Option<uint> // index of the final separator in repr
+ sepidx: Option<usize> // index of the final separator in repr
}
/// The standard path separator character
use super::*;
use clone::Clone;
- use iter::IteratorExt;
use option::Option::{self, Some, None};
use old_path::GenericPath;
use slice::AsSlice;
use str::{self, Str};
use string::ToString;
use vec::Vec;
+ use iter::Iterator;
macro_rules! t {
(s: $path:expr, $exp:expr) => (
use hash;
use old_io::Writer;
use iter::{AdditiveIterator, Extend};
-use iter::{Iterator, IteratorExt, Map, repeat};
+use iter::{Iterator, Map, repeat};
use mem;
use option::Option::{self, Some, None};
use result::Result::{self, Ok, Err};
pub struct Path {
repr: String, // assumed to never be empty
prefix: Option<PathPrefix>,
- sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
+ sepidx: Option<usize> // index of the final separator in the non-prefix portion of repr
}
#[stable(feature = "rust1", since = "1.0.0")]
if prefix.is_some() && comps.is_empty() {
match prefix.unwrap() {
DiskPrefix => {
- let len = prefix_len(prefix) + is_abs as uint;
+ let len = prefix_len(prefix) + is_abs as usize;
let mut s = String::from_str(&s[..len]);
unsafe {
let v = s.as_mut_vec();
Some(s)
}
VerbatimDiskPrefix => {
- let len = prefix_len(prefix) + is_abs as uint;
+ let len = prefix_len(prefix) + is_abs as usize;
let mut s = String::from_str(&s[..len]);
unsafe {
let v = s.as_mut_vec();
self.sepidx = idx.and_then(|x| if x < prefixlen { None } else { Some(x) });
}
- fn prefix_len(&self) -> uint {
+ fn prefix_len(&self) -> usize {
prefix_len(self.prefix)
}
// end is the length of the string, normally, or the index of the final character if it is
// a non-semantic trailing separator in a verbatim string.
// If the prefix is considered the separator, before and after are the same.
- fn sepidx_or_prefix_len(&self) -> Option<(uint,uint,uint)> {
+ fn sepidx_or_prefix_len(&self) -> Option<(usize,usize,usize)> {
match self.sepidx {
None => match self.prefix_len() { 0 => None, x => Some((x,x,self.repr.len())) },
Some(x) => {
/// Prefix types for Path
#[derive(Copy, PartialEq, Clone, Debug)]
pub enum PathPrefix {
- /// Prefix `\\?\`, uint is the length of the following component
- VerbatimPrefix(uint),
+ /// Prefix `\\?\`, usize is the length of the following component
+ VerbatimPrefix(usize),
/// Prefix `\\?\UNC\`, uints are the lengths of the UNC components
- VerbatimUNCPrefix(uint, uint),
+ VerbatimUNCPrefix(usize, usize),
/// Prefix `\\?\C:\` (for any alphabetic character)
VerbatimDiskPrefix,
- /// Prefix `\\.\`, uint is the length of the following component
- DeviceNSPrefix(uint),
+ /// Prefix `\\.\`, usize is the length of the following component
+ DeviceNSPrefix(usize),
/// UNC prefix `\\server\share`, uints are the lengths of the server/share
- UNCPrefix(uint, uint),
+ UNCPrefix(usize, usize),
/// Prefix `C:` for any alphabetic character
DiskPrefix
}
}
return None;
- fn parse_two_comps(mut path: &str, f: fn(char) -> bool) -> Option<(uint, uint)> {
+ fn parse_two_comps(mut path: &str, f: fn(char) -> bool) -> Option<(usize, usize)> {
let idx_a = match path.find(f) {
None => return None,
Some(x) => x
}
}
-fn prefix_len(p: Option<PathPrefix>) -> uint {
+fn prefix_len(p: Option<PathPrefix>) -> usize {
match p {
None => 0,
Some(VerbatimPrefix(x)) => 4 + x,
use super::*;
use clone::Clone;
- use iter::IteratorExt;
+ use iter::Iterator;
use option::Option::{self, Some, None};
use old_path::GenericPath;
use slice::AsSlice;
use error::{FromError, Error};
use ffi::{OsString, OsStr};
use fmt;
-use iter::{Iterator, IteratorExt};
+use iter::Iterator;
use libc::{c_void, c_int, c_char};
use libc;
use marker::{Copy, Send};
}
/// Get the number of cores available
-pub fn num_cpus() -> uint {
+pub fn num_cpus() -> usize {
unsafe {
- return rust_get_num_cpus() as uint;
+ return rust_get_num_cpus() as usize;
}
extern {
}
}
-pub const TMPBUF_SZ : uint = 1000;
+pub const TMPBUF_SZ : usize = 1000;
/// Returns the current working directory as a `Path`.
///
/// Note that this is not synchronized against modifications of other threads.
#[deprecated(since = "1.0.0", reason = "renamed to env::set_exit_status")]
#[unstable(feature = "os")]
-pub fn set_exit_status(code: int) {
+pub fn set_exit_status(code: isize) {
env::set_exit_status(code as i32)
}
/// by calling `set_exit_status`.
#[deprecated(since = "1.0.0", reason = "renamed to env::get_exit_status")]
#[unstable(feature = "os")]
-pub fn get_exit_status() -> int {
+pub fn get_exit_status() -> isize {
env::get_exit_status() as isize
}
#[cfg(target_os = "macos")]
-unsafe fn load_argc_and_argv(argc: int,
+unsafe fn load_argc_and_argv(argc: isize,
argv: *const *const c_char) -> Vec<Vec<u8>> {
use ffi::CStr;
#[cfg(target_os = "macos")]
fn real_args_as_bytes() -> Vec<Vec<u8>> {
unsafe {
- let (argc, argv) = (*_NSGetArgc() as int,
+ let (argc, argv) = (*_NSGetArgc() as isize,
*_NSGetArgv() as *const *const c_char);
load_argc_and_argv(argc, argv)
}
let info = objc_msgSend(klass, processInfoSel);
let args = objc_msgSend(info, argumentsSel);
- let cnt: int = mem::transmute(objc_msgSend(args, countSel));
+ let cnt: isize = mem::transmute(objc_msgSend(args, countSel));
for i in 0..cnt {
let tmp = objc_msgSend(args, objectAtSel, i);
let utf_c_str: *const libc::c_char =
let lpCmdLine = unsafe { GetCommandLineW() };
let szArgList = unsafe { CommandLineToArgvW(lpCmdLine, lpArgCount) };
- let args: Vec<_> = (0..nArgs as uint).map(|i| unsafe {
+ let args: Vec<_> = (0..nArgs as usize).map(|i| unsafe {
// Determine the length of this argument.
- let ptr = *szArgList.offset(i as int);
+ let ptr = *szArgList.offset(i as isize);
let mut len = 0;
- while *ptr.offset(len as int) != 0 { len += 1; }
+ while *ptr.offset(len as isize) != 0 { len += 1; }
// Push it onto the list.
let ptr = ptr as *const u16;
/// Returns the page size of the current architecture in bytes.
#[deprecated(since = "1.0.0", reason = "renamed to env::page_size")]
#[unstable(feature = "os")]
-pub fn page_size() -> uint {
+pub fn page_size() -> usize {
sys::os::page_size()
}
/// let it leave scope by accident if you want it to stick around.
pub struct MemoryMap {
data: *mut u8,
- len: uint,
+ len: usize,
kind: MemoryMapKind,
}
/// Create a memory mapping for a file with a given fd.
#[cfg(not(windows))]
MapFd(c_int),
- /// When using `MapFd`, the start of the map is `uint` bytes from the start
+ /// When using `MapFd`, the start of the map is `usize` bytes from the start
/// of the file.
- MapOffset(uint),
+ MapOffset(usize),
/// On POSIX, this can be used to specify the default flags passed to
/// `mmap`. By default it uses `MAP_PRIVATE` and, if not using `MapFd`,
/// `MAP_ANON`. This will override both of those. This is platform-specific
/// Not all platforms obey this, but this wrapper does.
ErrZeroLength,
/// Unrecognized error. The inner value is the unrecognized errno.
- ErrUnknown(int),
+ ErrUnknown(isize),
/// # The following are Windows-specific
///
/// Unsupported combination of protection flags
}
// Round up `from` to be divisible by `to`
-fn round_up(from: uint, to: uint) -> uint {
+fn round_up(from: usize, to: usize) -> usize {
let r = if from % to == 0 {
from
} else {
/// Create a new mapping with the given `options`, at least `min_len` bytes
/// long. `min_len` must be greater than zero; see the note on
/// `ErrZeroLength`.
- pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
+ pub fn new(min_len: usize, options: &[MapOption]) -> Result<MemoryMap, MapError> {
use libc::off_t;
if min_len == 0 {
libc::EINVAL => ErrUnaligned,
libc::ENODEV => ErrNoMapSupport,
libc::ENOMEM => ErrNoMem,
- code => ErrUnknown(code as int)
+ code => ErrUnknown(code as isize)
})
} else {
Ok(MemoryMap {
/// Granularity that the offset or address must be for `MapOffset` and
/// `MapAddr` respectively.
- pub fn granularity() -> uint {
+ pub fn granularity() -> usize {
env::page_size()
}
}
#[cfg(windows)]
impl MemoryMap {
/// Create a new mapping with the given `options`, at least `min_len` bytes long.
- pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
+ pub fn new(min_len: usize, options: &[MapOption]) -> Result<MemoryMap, MapError> {
use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE};
let mut lpAddress: LPVOID = ptr::null_mut();
let mut writable = false;
let mut executable = false;
let mut handle: HANDLE = libc::INVALID_HANDLE_VALUE;
- let mut offset: uint = 0;
+ let mut offset: usize = 0;
let len = round_up(min_len, env::page_size());
for &o in options {
libc::MEM_COMMIT | libc::MEM_RESERVE,
flProtect)
};
- match r as uint {
+ match r as usize {
0 => Err(ErrVirtualAlloc(errno())),
_ => Ok(MemoryMap {
data: r as *mut u8,
((len as u64) >> 32) as DWORD,
(offset & 0xffff_ffff) as DWORD,
0);
- match r as uint {
+ match r as usize {
0 => Err(ErrMapViewOfFile(errno())),
_ => Ok(MemoryMap {
data: r as *mut u8,
/// Granularity of MapAddr() and MapOffset() parameter values.
/// This may be greater than the value returned by page_size().
- pub fn granularity() -> uint {
+ pub fn granularity() -> usize {
use mem;
unsafe {
let mut info = mem::zeroed();
libc::GetSystemInfo(&mut info);
- return info.dwAllocationGranularity as uint;
+ return info.dwAllocationGranularity as usize;
}
}
}
/// Returns the pointer to the memory created or modified by this map.
pub fn data(&self) -> *mut u8 { self.data }
/// Returns the number of bytes this map applies to.
- pub fn len(&self) -> uint { self.len }
+ pub fn len(&self) -> usize { self.len }
/// Returns the type of mapping this represents.
pub fn kind(&self) -> MemoryMapKind { self.kind }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a Path> for PathBuf {
- fn from(s: &'a Path) -> PathBuf {
- s.to_path_buf()
+impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for PathBuf {
+ fn from(s: &'a T) -> PathBuf {
+ PathBuf::from(s.as_ref().to_os_string())
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for PathBuf {
- fn from(s: &'a str) -> PathBuf {
- PathBuf::from(OsString::from(s))
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a String> for PathBuf {
- fn from(s: &'a String) -> PathBuf {
- PathBuf::from(OsString::from(s))
+impl From<OsString> for PathBuf {
+ fn from(s: OsString) -> PathBuf {
+ PathBuf { inner: s }
}
}
}
}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a OsStr> for PathBuf {
- fn from(s: &'a OsStr) -> PathBuf {
- PathBuf::from(OsString::from(s))
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a OsString> for PathBuf {
- fn from(s: &'a OsString) -> PathBuf {
- PathBuf::from(s.to_os_string())
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl From<OsString> for PathBuf {
- fn from(s: OsString) -> PathBuf {
- PathBuf { inner: s }
- }
-}
-
#[stable(feature = "rust1", since = "1.0.0")]
impl<P: AsRef<Path>> iter::FromIterator<P> for PathBuf {
fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf {
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)] pub use iter::ExactSizeIterator;
#[stable(feature = "rust1", since = "1.0.0")]
-#[doc(no_inline)] pub use iter::{Iterator, IteratorExt, Extend};
+#[doc(no_inline)] pub use iter::{Iterator, Extend};
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)] pub use option::Option::{self, Some, None};
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)] pub use string::{String, ToString};
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)] pub use vec::Vec;
-
-// FIXME(#23454) should these be here?
-#[doc(no_inline)] pub use num::wrapping::{Wrapping, WrappingOps};
///
/// # Examples
///
-/// ```should_fail
+/// ```should_panic
/// # #![feature(process)]
///
/// use std::process::Command;
//!
//! let mut rng = rand::thread_rng();
//! if rng.gen() { // random bool
-//! println!("int: {}, uint: {}", rng.gen::<int>(), rng.gen::<uint>())
+//! println!("isize: {}, usize: {}", rng.gen::<isize>(), rng.gen::<usize>())
//! }
//! ```
//!
//! }
//!
//! // Run a single simulation of the Monty Hall problem.
-//! fn simulate<R: Rng>(random_door: &Range<uint>, rng: &mut R) -> SimulationResult {
+//! fn simulate<R: Rng>(random_door: &Range<usize>, rng: &mut R) -> SimulationResult {
//! let car = random_door.ind_sample(rng);
//!
//! // This is our initial choice
//!
//! // Returns the door the game host opens given our choice and knowledge of
//! // where the car is. The game host will never open the door with the car.
-//! fn game_host_open<R: Rng>(car: uint, choice: uint, rng: &mut R) -> uint {
+//! fn game_host_open<R: Rng>(car: usize, choice: usize, rng: &mut R) -> usize {
//! let choices = free_doors(&[car, choice]);
//! rand::sample(rng, choices.into_iter(), 1)[0]
//! }
//!
//! // Returns the door we switch to, given our current choice and
//! // the open door. There will only be one valid door.
-//! fn switch_door(choice: uint, open: uint) -> uint {
+//! fn switch_door(choice: usize, open: usize) -> usize {
//! free_doors(&[choice, open])[0]
//! }
//!
-//! fn free_doors(blocked: &[uint]) -> Vec<uint> {
+//! fn free_doors(blocked: &[usize]) -> Vec<usize> {
//! (0..3).filter(|x| !blocked.contains(x)).collect()
//! }
//!
use cell::RefCell;
use clone::Clone;
use old_io::IoResult;
-use iter::{Iterator, IteratorExt};
+use iter::Iterator;
use mem;
use rc::Rc;
use result::Result::{Ok, Err};
/// Retrieve the lazily-initialized thread-local random number
/// generator, seeded by the system. Intended to be used in method
-/// chaining style, e.g. `thread_rng().gen::<int>()`.
+/// chaining style, e.g. `thread_rng().gen::<isize>()`.
///
/// The RNG provided will reseed itself from the operating system
/// after generating a certain amount of randomness.
let mut r = thread_rng();
assert_eq!(r.choose(&[1, 1, 1]).cloned(), Some(1));
- let v: &[int] = &[];
+ let v: &[isize] = &[];
assert_eq!(r.choose(v), None);
}
#[test]
fn test_shuffle() {
let mut r = thread_rng();
- let empty: &mut [int] = &mut [];
+ let empty: &mut [isize] = &mut [];
r.shuffle(empty);
let mut one = [1];
r.shuffle(&mut one);
#[test]
fn test_thread_rng() {
let mut r = thread_rng();
- r.gen::<int>();
+ r.gen::<isize>();
let mut v = [1, 1, 1];
r.shuffle(&mut v);
let b: &[_] = &[1, 1, 1];
#[test]
fn test_random() {
// not sure how to test this aside from just getting some values
- let _n : uint = random();
+ let _n : usize = random();
let _f : f32 = random();
let _o : Option<Option<i8>> = random();
let _many : ((),
- (uint,
- int,
+ (usize,
+ isize,
Option<(u32, (bool,))>),
(u8, i8, u16, i16, u32, i32, u64, i64),
(f32, (f64, (f64,)))) = random();
let max_val = 100;
let mut r = thread_rng();
- let vals = (min_val..max_val).collect::<Vec<int>>();
+ let vals = (min_val..max_val).collect::<Vec<isize>>();
let small_sample = sample(&mut r, vals.iter(), 5);
let large_sample = sample(&mut r, vals.iter(), vals.len() + 5);
#[test]
fn test_std_rng_seeded() {
- let s = thread_rng().gen_iter::<uint>().take(256).collect::<Vec<uint>>();
+ let s = thread_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>();
let mut ra: StdRng = SeedableRng::from_seed(&*s);
let mut rb: StdRng = SeedableRng::from_seed(&*s);
assert!(order::equals(ra.gen_ascii_chars().take(100),
#[test]
fn test_std_rng_reseed() {
- let s = thread_rng().gen_iter::<uint>().take(256).collect::<Vec<uint>>();
+ let s = thread_rng().gen_iter::<usize>().take(256).collect::<Vec<usize>>();
let mut r: StdRng = SeedableRng::from_seed(&*s);
let string1 = r.gen_ascii_chars().take(100).collect::<String>();
let mut rng: XorShiftRng = OsRng::new().unwrap().gen();
b.iter(|| {
for _ in 0..RAND_BENCH_N {
- rng.gen::<uint>();
+ rng.gen::<usize>();
}
});
- b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
+ b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
}
#[bench]
let mut rng: IsaacRng = OsRng::new().unwrap().gen();
b.iter(|| {
for _ in 0..RAND_BENCH_N {
- rng.gen::<uint>();
+ rng.gen::<usize>();
}
});
- b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
+ b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
}
#[bench]
let mut rng: Isaac64Rng = OsRng::new().unwrap().gen();
b.iter(|| {
for _ in 0..RAND_BENCH_N {
- rng.gen::<uint>();
+ rng.gen::<usize>();
}
});
- b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
+ b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
}
#[bench]
let mut rng = StdRng::new().unwrap();
b.iter(|| {
for _ in 0..RAND_BENCH_N {
- rng.gen::<uint>();
+ rng.gen::<usize>();
}
});
- b.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
+ b.bytes = size_of::<usize>() as u64 * RAND_BENCH_N;
}
#[bench]
fn rand_shuffle_100(b: &mut Bencher) {
let mut rng = weak_rng();
- let x : &mut[uint] = &mut [1; 100];
+ let x : &mut[usize] = &mut [1; 100];
b.iter(|| {
rng.shuffle(x);
})
/// use std::old_io::MemReader;
///
/// let mut rng = reader::ReaderRng::new(MemReader::new(vec!(1,2,3,4,5,6,7,8)));
-/// println!("{:x}", rng.gen::<uint>());
+/// println!("{:x}", rng.gen::<usize>());
/// ```
pub struct ReaderRng<R> {
reader: R
use vec::Vec;
/// One-time global initialization.
-pub unsafe fn init(argc: int, argv: *const *const u8) { imp::init(argc, argv) }
+pub unsafe fn init(argc: isize, argv: *const *const u8) { imp::init(argc, argv) }
/// One-time global cleanup.
pub unsafe fn cleanup() { imp::cleanup() }
use sync::{StaticMutex, MUTEX_INIT};
- static mut GLOBAL_ARGS_PTR: uint = 0;
+ static mut GLOBAL_ARGS_PTR: usize = 0;
static LOCK: StaticMutex = MUTEX_INIT;
- pub unsafe fn init(argc: int, argv: *const *const u8) {
+ pub unsafe fn init(argc: isize, argv: *const *const u8) {
let args = load_argc_and_argv(argc, argv);
put(args);
}
use core::prelude::*;
use vec::Vec;
- pub unsafe fn init(_argc: int, _argv: *const *const u8) {
+ pub unsafe fn init(_argc: isize, _argv: *const *const u8) {
}
pub fn cleanup() {
pub type _Unwind_Word = libc::uintptr_t;
#[cfg(target_arch = "x86")]
-pub const unwinder_private_data_size: uint = 5;
+pub const unwinder_private_data_size: usize = 5;
#[cfg(target_arch = "x86_64")]
-pub const unwinder_private_data_size: uint = 6;
+pub const unwinder_private_data_size: usize = 6;
#[cfg(all(target_arch = "arm", not(target_os = "ios")))]
-pub const unwinder_private_data_size: uint = 20;
+pub const unwinder_private_data_size: usize = 20;
#[cfg(all(target_arch = "arm", target_os = "ios"))]
-pub const unwinder_private_data_size: uint = 5;
+pub const unwinder_private_data_size: usize = 5;
#[cfg(target_arch = "aarch64")]
-pub const unwinder_private_data_size: uint = 2;
+pub const unwinder_private_data_size: usize = 2;
#[cfg(any(target_arch = "mips", target_arch = "mipsel"))]
-pub const unwinder_private_data_size: uint = 2;
+pub const unwinder_private_data_size: usize = 2;
#[cfg(target_arch = "powerpc")]
-pub const unwinder_private_data_size: uint = 2;
+pub const unwinder_private_data_size: usize = 2;
#[repr(C)]
pub struct _Unwind_Exception {
/// The default error code of the rust runtime if the main thread panics instead
/// of exiting cleanly.
-pub const DEFAULT_ERROR_CODE: int = 101;
+pub const DEFAULT_ERROR_CODE: isize = 101;
#[cfg(any(windows, android))]
-const OS_DEFAULT_STACK_ESTIMATE: uint = 1 << 20;
+const OS_DEFAULT_STACK_ESTIMATE: usize = 1 << 20;
#[cfg(all(unix, not(android)))]
-const OS_DEFAULT_STACK_ESTIMATE: uint = 2 * (1 << 20);
+const OS_DEFAULT_STACK_ESTIMATE: usize = 2 * (1 << 20);
#[cfg(not(test))]
#[lang = "start"]
-fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int {
+fn lang_start(main: *const u8, argc: isize, argv: *const *const u8) -> isize {
use prelude::v1::*;
use mem;
use thread::Thread;
let something_around_the_top_of_the_stack = 1;
- let addr = &something_around_the_top_of_the_stack as *const _ as *const int;
- let my_stack_top = addr as uint;
+ let addr = &something_around_the_top_of_the_stack as *const _ as *const isize;
+ let my_stack_top = addr as usize;
// FIXME #11359 we just assume that this thread has a stack of a
// certain size, and estimate that there's at most 20KB of stack
// frames above our current position.
- const TWENTY_KB: uint = 20000;
+ const TWENTY_KB: usize = 20000;
// saturating-add to sidestep overflow
let top_plus_spill = if usize::MAX - TWENTY_KB < my_stack_top {
cause: Option<Box<Any + Send + 'static>>,
}
-pub type Callback = fn(msg: &(Any + Send), file: &'static str, line: uint);
+pub type Callback = fn(msg: &(Any + Send), file: &'static str, line: usize);
// Variables used for invoking callbacks when a thread starts to unwind.
//
// For more information, see below.
-const MAX_CALLBACKS: uint = 16;
+const MAX_CALLBACKS: usize = 16;
static CALLBACKS: [atomic::AtomicUsize; MAX_CALLBACKS] =
[atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
atomic::ATOMIC_USIZE_INIT, atomic::ATOMIC_USIZE_INIT,
};
let exception_param = boxed::into_raw(exception) as *mut uw::_Unwind_Exception;
let error = uw::_Unwind_RaiseException(exception_param);
- rtabort!("Could not unwind stack, error = {}", error as int)
+ rtabort!("Could not unwind stack, error = {}", error as isize)
}
extern fn exception_cleanup(_unwind_code: uw::_Unwind_Reason_Code,
/// Entry point of panic from the libcore crate.
#[lang = "panic_fmt"]
pub extern fn rust_begin_unwind(msg: fmt::Arguments,
- file: &'static str, line: uint) -> ! {
+ file: &'static str, line: usize) -> ! {
begin_unwind_fmt(msg, &(file, line))
}
/// the actual formatting into this shared place.
#[inline(never)] #[cold]
#[stable(since = "1.0.0", feature = "rust1")]
-pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
+pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, usize)) -> ! {
use fmt::Write;
// We do two allocations here, unfortunately. But (a) they're
/// This is the entry point of unwinding for panic!() and assert!().
#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
#[stable(since = "1.0.0", feature = "rust1")]
-pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, uint)) -> ! {
+pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, usize)) -> ! {
// Note that this should be the only allocation performed in this code path.
// Currently this means that panic!() on OOM will invoke this code path,
// but then again we're not really ready for panic on OOM anyway. If
/// }` from ~1900/3700 (-O/no opts) to 180/590.
#[inline(never)] #[cold] // this is the slow path, please never inline this
fn begin_unwind_inner(msg: Box<Any + Send>,
- file_line: &(&'static str, uint)) -> ! {
+ file_line: &(&'static str, usize)) -> ! {
// Make sure the default failure handler is registered before we look at the
// callbacks. We also use a raw sys-based mutex here instead of a
// `std::sync` one as accessing TLS can cause weird recursive problems (and
(cfg!(target_os="macos")) && running_on_valgrind()
}
-pub fn min_stack() -> uint {
+pub fn min_stack() -> usize {
static MIN: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
match MIN.load(Ordering::SeqCst) {
0 => {}
use self::FutureState::*;
use sync::mpsc::{Receiver, channel};
-use thunk::{Thunk};
+use thunk::Thunk;
use thread;
/// A type encapsulating the result of a computation which may not be complete
#[test]
fn drop_full() {
- let (tx, _rx) = channel::<Box<int>>();
+ let (tx, _rx) = channel::<Box<isize>>();
tx.send(box 1).unwrap();
}
#[test]
fn drop_full_shared() {
- let (tx, _rx) = channel::<Box<int>>();
+ let (tx, _rx) = channel::<Box<isize>>();
drop(tx.clone());
drop(tx.clone());
tx.send(box 1).unwrap();
#[test]
fn oneshot_multi_thread_send_recv_stress() {
for _ in 0..stress_factor() {
- let (tx, rx) = channel::<Box<int>>();
+ let (tx, rx) = channel::<Box<isize>>();
let _t = thread::spawn(move|| {
tx.send(box 10).unwrap();
});
#[test]
fn drop_full() {
- let (tx, _rx) = sync_channel::<Box<int>>(1);
+ let (tx, _rx) = sync_channel::<Box<isize>>(1);
tx.send(box 1).unwrap();
}
}
// increment the count on the channel (used for selection)
- fn bump(&mut self, amt: int) -> int {
+ fn bump(&mut self, amt: isize) -> isize {
match self.cnt.fetch_add(amt, Ordering::SeqCst) {
DISCONNECTED => {
self.cnt.store(DISCONNECTED, Ordering::SeqCst);
let arc2 = arc.clone();
let _ = thread::spawn(move|| -> () {
struct Unwinder {
- i: Arc<RwLock<int>>,
+ i: Arc<RwLock<isize>>,
}
impl Drop for Unwinder {
fn drop(&mut self) {
/// sem.release();
/// ```
pub struct Semaphore {
- lock: Mutex<int>,
+ lock: Mutex<isize>,
cvar: Condvar,
}
/// The count specified can be thought of as a number of resources, and a
/// call to `acquire` or `access` will block until at least one resource is
/// available. It is valid to initialize a semaphore with a negative count.
- pub fn new(count: int) -> Semaphore {
+ pub fn new(count: isize) -> Semaphore {
Semaphore {
lock: Mutex::new(count),
cvar: Condvar::new(),
use io;
#[cfg(target_pointer_width = "64")]
-pub const HEX_WIDTH: uint = 18;
+pub const HEX_WIDTH: usize = 18;
#[cfg(target_pointer_width = "32")]
-pub const HEX_WIDTH: uint = 10;
+pub const HEX_WIDTH: usize = 10;
// All rust symbols are in theory lists of "::"-separated identifiers. Some
// assemblers, however, can't handle these characters in symbol names. To get
let mut i = 0;
for c in chars.by_ref() {
if c.is_numeric() {
- i = i * 10 + c as uint - '0' as uint;
+ i = i * 10 + c as usize - '0' as usize;
} else {
break
}
while rest.char_at(0).is_numeric() {
rest = &rest[1..];
}
- let i: uint = inner[.. (inner.len() - rest.len())].parse().unwrap();
+ let i: usize = inner[.. (inner.len() - rest.len())].parse().unwrap();
inner = &rest[i..];
rest = &rest[..i];
while rest.len() > 0 {
pub chan: UnsafeCell<*mut Sender<M>>,
/// OS handle used to wake up a blocked helper thread
- pub signal: UnsafeCell<uint>,
+ pub signal: UnsafeCell<usize>,
/// Flag if this helper thread has booted and been initialized yet.
pub initialized: UnsafeCell<bool>,
{
unsafe {
let _guard = self.lock.lock().unwrap();
- if *self.chan.get() as uint == 0 {
+ if *self.chan.get() as usize == 0 {
let (tx, rx) = channel();
*self.chan.get() = boxed::into_raw(box tx);
let (receive, send) = helper_signal::new();
- *self.signal.get() = send as uint;
+ *self.signal.get() = send as usize;
let receive = RaceBox(receive);
let _ = rt::at_exit(move || { self.shutdown() });
*self.initialized.get() = true;
- } else if *self.chan.get() as uint == 1 {
+ } else if *self.chan.get() as usize == 1 {
panic!("cannot continue usage after shutdown");
}
}
// Must send and *then* signal to ensure that the child receives the
// message. Otherwise it could wake up and go to sleep before we
// send the message.
- assert!(*self.chan.get() as uint != 0);
- assert!(*self.chan.get() as uint != 1,
+ assert!(*self.chan.get() as usize != 0);
+ assert!(*self.chan.get() as usize != 1,
"cannot continue usage after shutdown");
(**self.chan.get()).send(msg).unwrap();
helper_signal::signal(*self.signal.get() as helper_signal::signal);
let mut guard = self.lock.lock().unwrap();
let ptr = *self.chan.get();
- if ptr as uint == 1 {
+ if ptr as usize == 1 {
panic!("cannot continue usage after shutdown");
}
// Close the channel by destroying it
use prelude::v1::*;
use sys::{last_error, retry};
use ffi::CString;
+#[allow(deprecated)] // Int
use num::Int;
#[allow(deprecated)]
}
#[allow(deprecated)]
-pub fn short_write(n: uint, desc: &'static str) -> IoError {
+pub fn short_write(n: usize, desc: &'static str) -> IoError {
IoError {
kind: if n == 0 { old_io::TimedOut } else { old_io::ShortWrite(n) },
desc: desc,
}
pub fn keep_going<F>(data: &[u8], mut f: F) -> i64 where
- F: FnMut(*const u8, uint) -> i64,
+ F: FnMut(*const u8, usize) -> i64,
{
let origamt = data.len();
let mut data = data.as_ptr();
if ret == 0 {
break
} else if ret != -1 {
- amt -= ret as uint;
- data = unsafe { data.offset(ret as int) };
+ amt -= ret as usize;
+ data = unsafe { data.offset(ret as isize) };
} else {
return ret;
}
fn args(&self) -> &[CString];
fn env(&self) -> Option<&collections::HashMap<K, V>>;
fn cwd(&self) -> Option<&CString>;
- fn uid(&self) -> Option<uint>;
- fn gid(&self) -> Option<uint>;
+ fn uid(&self) -> Option<usize>;
+ fn gid(&self) -> Option<usize>;
fn detach(&self) -> bool;
}
if ret != 0 {
Err(last_net_error())
} else {
- assert!(len as uint == mem::size_of::<T>());
+ assert!(len as usize == mem::size_of::<T>());
Ok(slot)
}
}
return Err(last_net_error())
}
}
- return sockaddr_to_addr(&storage, len as uint);
+ return sockaddr_to_addr(&storage, len as usize);
}
pub fn sockaddr_to_addr(storage: &libc::sockaddr_storage,
- len: uint) -> IoResult<SocketAddr> {
+ len: usize) -> IoResult<SocketAddr> {
match storage.ss_family as libc::c_int {
libc::AF_INET => {
- assert!(len as uint >= mem::size_of::<libc::sockaddr_in>());
+ assert!(len as usize >= mem::size_of::<libc::sockaddr_in>());
let storage: &libc::sockaddr_in = unsafe {
mem::transmute(storage)
};
})
}
libc::AF_INET6 => {
- assert!(len as uint >= mem::size_of::<libc::sockaddr_in6>());
+ assert!(len as usize >= mem::size_of::<libc::sockaddr_in6>());
let storage: &libc::sockaddr_in6 = unsafe {
mem::transmute(storage)
};
while !rp.is_null() {
unsafe {
let addr = try!(sockaddr_to_addr(mem::transmute((*rp).ai_addr),
- (*rp).ai_addrlen as uint));
+ (*rp).ai_addrlen as usize));
addrs.push(addrinfo::Info {
address: addr,
- family: (*rp).ai_family as uint,
+ family: (*rp).ai_family as usize,
socktype: None,
protocol: None,
- flags: (*rp).ai_flags as uint
+ flags: (*rp).ai_flags as usize
});
rp = (*rp).ai_next as *mut libc::addrinfo;
flags: c_int) -> c_int;
}
-const NI_MAXHOST: uint = 1025;
+const NI_MAXHOST: usize = 1025;
pub fn get_address_name(addr: IpAddr) -> Result<String, IoError> {
let addr = SocketAddr{ip: addr, port: 0};
// [1] http://twistedmatrix.com/pipermail/twisted-commits/2012-April/034692.html
// [2] http://stackoverflow.com/questions/19819198/does-send-msg-dontwait
-pub fn read<T, L, R>(fd: sock_t, deadline: u64, mut lock: L, mut read: R) -> IoResult<uint> where
+pub fn read<T, L, R>(fd: sock_t, deadline: u64, mut lock: L, mut read: R) -> IoResult<usize> where
L: FnMut() -> T,
R: FnMut(bool) -> libc::c_int,
{
match ret {
0 => Err(sys_common::eof()),
n if n < 0 => Err(last_net_error()),
- n => Ok(n as uint)
+ n => Ok(n as usize)
}
}
buf: &[u8],
write_everything: bool,
mut lock: L,
- mut write: W) -> IoResult<uint> where
+ mut write: W) -> IoResult<usize> where
L: FnMut() -> T,
- W: FnMut(bool, *const u8, uint) -> i64,
+ W: FnMut(bool, *const u8, usize) -> i64,
{
let mut ret = -1;
let mut written = 0;
});
} else {
ret = retry(|| { write(false, buf.as_ptr(), buf.len()) });
- if ret > 0 { written = ret as uint; }
+ if ret > 0 { written = ret as usize; }
}
}
match retry(|| write(deadline.is_some(), ptr, len)) {
-1 if wouldblock() => {}
-1 => return Err(last_net_error()),
- n => { written += n as uint; }
+ n => { written += n as usize; }
}
}
ret = 0;
// If the connection is in progress, then we need to wait for it to
// finish (with a timeout). The current strategy for doing this is
// to use select() with a timeout.
- -1 if os::errno() as int == INPROGRESS as int ||
- os::errno() as int == WOULDBLOCK as int => {
+ -1 if os::errno() as isize == INPROGRESS as isize ||
+ os::errno() as isize == WOULDBLOCK as isize => {
let mut set: c::fd_set = unsafe { mem::zeroed() };
c::fd_set(&mut set, fd);
match await(fd, &mut set, timeout_ms) {
nodelay as libc::c_int)
}
- pub fn set_keepalive(&mut self, seconds: Option<uint>) -> IoResult<()> {
+ pub fn set_keepalive(&mut self, seconds: Option<usize>) -> IoResult<()> {
let ret = setsockopt(self.fd(), libc::SOL_SOCKET, libc::SO_KEEPALIVE,
seconds.is_some() as libc::c_int);
match seconds {
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
- fn set_tcp_keepalive(&mut self, seconds: uint) -> IoResult<()> {
+ fn set_tcp_keepalive(&mut self, seconds: usize) -> IoResult<()> {
setsockopt(self.fd(), libc::IPPROTO_TCP, libc::TCP_KEEPALIVE,
seconds as libc::c_int)
}
#[cfg(any(target_os = "freebsd",
target_os = "dragonfly"))]
- fn set_tcp_keepalive(&mut self, seconds: uint) -> IoResult<()> {
+ fn set_tcp_keepalive(&mut self, seconds: usize) -> IoResult<()> {
setsockopt(self.fd(), libc::IPPROTO_TCP, libc::TCP_KEEPIDLE,
seconds as libc::c_int)
}
#[cfg(target_os = "openbsd")]
- fn set_tcp_keepalive(&mut self, seconds: uint) -> IoResult<()> {
+ fn set_tcp_keepalive(&mut self, seconds: usize) -> IoResult<()> {
setsockopt(self.fd(), libc::IPPROTO_TCP, libc::SO_KEEPALIVE,
seconds as libc::c_int)
}
target_os = "freebsd",
target_os = "dragonfly",
target_os = "openbsd")))]
- fn set_tcp_keepalive(&mut self, _seconds: uint) -> IoResult<()> {
+ fn set_tcp_keepalive(&mut self, _seconds: usize) -> IoResult<()> {
Ok(())
}
ret
}
- pub fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let fd = self.fd();
let dolock = || self.lock_nonblocking();
let doread = |nb| unsafe {
pub fn write(&mut self, buf: &[u8]) -> IoResult<()> {
let fd = self.fd();
let dolock = || self.lock_nonblocking();
- let dowrite = |nb: bool, buf: *const u8, len: uint| unsafe {
+ let dowrite = |nb: bool, buf: *const u8, len: usize| unsafe {
let flags = if nb {c::MSG_DONTWAIT} else {0};
libc::send(fd,
buf as *const _,
sockname(self.fd(), libc::getsockname)
}
- pub fn recv_from(&mut self, buf: &mut [u8]) -> IoResult<(uint, SocketAddr)> {
+ pub fn recv_from(&mut self, buf: &mut [u8]) -> IoResult<(usize, SocketAddr)> {
let fd = self.fd();
let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
let storagep = &mut storage as *mut _ as *mut libc::sockaddr;
storagep,
&mut addrlen) as libc::c_int
}));
- Ok((n as uint, sockaddr_to_addr(&storage, addrlen as uint).unwrap()))
+ Ok((n as usize, sockaddr_to_addr(&storage, addrlen as usize).unwrap()))
}
pub fn send_to(&mut self, buf: &[u8], dst: SocketAddr) -> IoResult<()> {
let fd = self.fd();
let dolock = || self.lock_nonblocking();
- let dowrite = |nb, buf: *const u8, len: uint| unsafe {
+ let dowrite = |nb, buf: *const u8, len: usize| unsafe {
let flags = if nb {c::MSG_DONTWAIT} else {0};
libc::sendto(fd,
buf as *const libc::c_void,
}
}
- pub fn multicast_time_to_live(&mut self, ttl: int) -> IoResult<()> {
+ pub fn multicast_time_to_live(&mut self, ttl: isize) -> IoResult<()> {
setsockopt(self.fd(), libc::IPPROTO_IP, libc::IP_MULTICAST_TTL,
ttl as libc::c_int)
}
- pub fn time_to_live(&mut self, ttl: int) -> IoResult<()> {
+ pub fn time_to_live(&mut self, ttl: isize) -> IoResult<()> {
setsockopt(self.fd(), libc::IPPROTO_IP, libc::IP_TTL, ttl as libc::c_int)
}
// corresponding prolog, decision was taken to disable segmented
// stack support on iOS.
-pub const RED_ZONE: uint = 20 * 1024;
+pub const RED_ZONE: usize = 20 * 1024;
/// This function is invoked from rust's current __morestack function. Segmented
/// stacks are currently not enabled as segmented stacks, but rather one giant
// On all other platforms both variants behave identically.
#[inline(always)]
-pub unsafe fn record_os_managed_stack_bounds(stack_lo: uint, _stack_hi: uint) {
+pub unsafe fn record_os_managed_stack_bounds(stack_lo: usize, _stack_hi: usize) {
record_sp_limit(stack_lo + RED_ZONE);
}
/// would be unfortunate for the functions themselves to trigger a morestack
/// invocation (if they were an actual function call).
#[inline(always)]
-pub unsafe fn record_sp_limit(limit: uint) {
+pub unsafe fn record_sp_limit(limit: usize) {
return target_record_sp_limit(limit);
// x86-64
#[cfg(all(target_arch = "x86_64",
any(target_os = "macos", target_os = "ios")))]
#[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
asm!("movq $$0x60+90*8, %rsi
movq $0, %gs:(%rsi)" :: "r"(limit) : "rsi" : "volatile")
}
#[cfg(all(target_arch = "x86_64", target_os = "linux"))] #[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
asm!("movq $0, %fs:112" :: "r"(limit) :: "volatile")
}
#[cfg(all(target_arch = "x86_64", target_os = "windows"))] #[inline(always)]
- unsafe fn target_record_sp_limit(_: uint) {
+ unsafe fn target_record_sp_limit(_: usize) {
}
#[cfg(all(target_arch = "x86_64", target_os = "freebsd"))] #[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
asm!("movq $0, %fs:24" :: "r"(limit) :: "volatile")
}
#[cfg(all(target_arch = "x86_64", target_os = "dragonfly"))]
#[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
asm!("movq $0, %fs:32" :: "r"(limit) :: "volatile")
}
#[cfg(all(target_arch = "x86",
any(target_os = "macos", target_os = "ios")))]
#[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
asm!("movl $$0x48+90*4, %eax
movl $0, %gs:(%eax)" :: "r"(limit) : "eax" : "volatile")
}
#[cfg(all(target_arch = "x86",
any(target_os = "linux", target_os = "freebsd")))]
#[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
asm!("movl $0, %gs:48" :: "r"(limit) :: "volatile")
}
#[cfg(all(target_arch = "x86", target_os = "windows"))] #[inline(always)]
- unsafe fn target_record_sp_limit(_: uint) {
+ unsafe fn target_record_sp_limit(_: usize) {
}
// mips, arm - Some brave soul can port these to inline asm, but it's over
target_arch = "mipsel",
all(target_arch = "arm", not(target_os = "ios"))))]
#[inline(always)]
- unsafe fn target_record_sp_limit(limit: uint) {
+ unsafe fn target_record_sp_limit(limit: usize) {
use libc::c_void;
return record_sp_limit(limit as *const c_void);
extern {
all(target_arch = "arm", target_os = "ios"),
target_os = "bitrig",
target_os = "openbsd"))]
- unsafe fn target_record_sp_limit(_: uint) {
+ unsafe fn target_record_sp_limit(_: usize) {
}
}
/// As with the setter, this function does not have a __morestack header and can
/// therefore be called in a "we're out of stack" situation.
#[inline(always)]
-pub unsafe fn get_sp_limit() -> uint {
+pub unsafe fn get_sp_limit() -> usize {
return target_get_sp_limit();
// x86-64
#[cfg(all(target_arch = "x86_64",
any(target_os = "macos", target_os = "ios")))]
#[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
let limit;
asm!("movq $$0x60+90*8, %rsi
movq %gs:(%rsi), $0" : "=r"(limit) :: "rsi" : "volatile");
return limit;
}
#[cfg(all(target_arch = "x86_64", target_os = "linux"))] #[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
let limit;
asm!("movq %fs:112, $0" : "=r"(limit) ::: "volatile");
return limit;
}
#[cfg(all(target_arch = "x86_64", target_os = "windows"))] #[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
return 1024;
}
#[cfg(all(target_arch = "x86_64", target_os = "freebsd"))] #[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
let limit;
asm!("movq %fs:24, $0" : "=r"(limit) ::: "volatile");
return limit;
}
#[cfg(all(target_arch = "x86_64", target_os = "dragonfly"))]
#[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
let limit;
asm!("movq %fs:32, $0" : "=r"(limit) ::: "volatile");
return limit;
#[cfg(all(target_arch = "x86",
any(target_os = "macos", target_os = "ios")))]
#[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
let limit;
asm!("movl $$0x48+90*4, %eax
movl %gs:(%eax), $0" : "=r"(limit) :: "eax" : "volatile");
#[cfg(all(target_arch = "x86",
any(target_os = "linux", target_os = "freebsd")))]
#[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
let limit;
asm!("movl %gs:48, $0" : "=r"(limit) ::: "volatile");
return limit;
}
#[cfg(all(target_arch = "x86", target_os = "windows"))] #[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
return 1024;
}
target_arch = "mipsel",
all(target_arch = "arm", not(target_os = "ios"))))]
#[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
use libc::c_void;
- return get_sp_limit() as uint;
+ return get_sp_limit() as usize;
extern {
fn get_sp_limit() -> *const c_void;
}
target_os = "bitrig",
target_os = "openbsd"))]
#[inline(always)]
- unsafe fn target_get_sp_limit() -> uint {
+ unsafe fn target_get_sp_limit() -> usize {
1024
}
}
use thread::LocalKeyState;
struct ThreadInfo {
- stack_guard: uint,
+ stack_guard: usize,
thread: Thread,
}
ThreadInfo::with(|info| info.thread.clone())
}
-pub fn stack_guard() -> uint {
+pub fn stack_guard() -> usize {
ThreadInfo::with(|info| info.stack_guard)
}
-pub fn set(stack_guard: uint, thread: Thread) {
+pub fn set(stack_guard: usize, thread: Thread) {
THREAD_INFO.with(|c| assert!(c.borrow().is_none()));
THREAD_INFO.with(move |c| *c.borrow_mut() = Some(ThreadInfo{
stack_guard: stack_guard,
}
}
- unsafe fn lazy_init(&self) -> uint {
+ unsafe fn lazy_init(&self) -> usize {
// POSIX allows the key created here to be 0, but the compare_and_swap
// below relies on using 0 as a sentinel value to check who won the
// race to set the shared TLS key. As far as I know, there is no
key2
};
assert!(key != 0);
- match self.inner.key.compare_and_swap(0, key as uint, Ordering::SeqCst) {
+ match self.inner.key.compare_and_swap(0, key as usize, Ordering::SeqCst) {
// The CAS succeeded, so we've created the actual key
- 0 => key as uint,
+ 0 => key as usize,
// If someone beat us to the punch, use their key instead
n => { imp::destroy(key); n }
}
assert!(k2.get().is_null());
k1.set(1 as *mut _);
k2.set(2 as *mut _);
- assert_eq!(k1.get() as uint, 1);
- assert_eq!(k2.get() as uint, 2);
+ assert_eq!(k1.get() as usize, 1);
+ assert_eq!(k2.get() as usize, 2);
}
#[test]
assert!(K2.get().is_null());
K1.set(1 as *mut _);
K2.set(2 as *mut _);
- assert_eq!(K1.get() as uint, 1);
- assert_eq!(K2.get() as uint, 2);
+ assert_eq!(K1.get() as usize, 1);
+ assert_eq!(K2.get() as usize, 2);
}
}
}
use hash::{Hash, Hasher};
use iter::{FromIterator, IntoIterator};
use mem;
+#[allow(deprecated)] // Int
use num::Int;
use ops;
use slice;
/// Create an new, empty WTF-8 string with pre-allocated capacity for `n` bytes.
#[inline]
- pub fn with_capacity(n: uint) -> Wtf8Buf {
+ pub fn with_capacity(n: usize) -> Wtf8Buf {
Wtf8Buf { bytes: Vec::with_capacity(n) }
}
// Attempt to not use an intermediate buffer by just pushing bytes
// directly onto this string.
let slice = slice::from_raw_parts_mut(
- self.bytes.as_mut_ptr().offset(cur_len as int),
+ self.bytes.as_mut_ptr().offset(cur_len as isize),
4
);
let used = encode_utf8_raw(code_point.value, mem::transmute(slice))
///
/// # Panics
///
- /// Panics if the new capacity overflows `uint`.
+ /// Panics if the new capacity overflows `usize`.
#[inline]
- pub fn reserve(&mut self, additional: uint) {
+ pub fn reserve(&mut self, additional: usize) {
self.bytes.reserve(additional)
}
/// Returns the number of bytes that this string buffer can hold without reallocating.
#[inline]
- pub fn capacity(&self) -> uint {
+ pub fn capacity(&self) -> usize {
self.bytes.capacity()
}
/// Panics if `new_len` > current length,
/// or if `new_len` is not a code point boundary.
#[inline]
- pub fn truncate(&mut self, new_len: uint) {
+ pub fn truncate(&mut self, new_len: usize) {
assert!(is_code_point_boundary(self, new_len));
self.bytes.truncate(new_len)
}
Some((surrogate_pos, _)) => {
pos = surrogate_pos + 3;
slice::bytes::copy_memory(
+ UTF8_REPLACEMENT_CHARACTER,
&mut self.bytes[surrogate_pos .. pos],
- UTF8_REPLACEMENT_CHARACTER
);
},
None => return unsafe { String::from_utf8_unchecked(self.bytes) }
/// Return the length, in WTF-8 bytes.
#[inline]
- pub fn len(&self) -> uint {
+ pub fn len(&self) -> usize {
self.bytes.len()
}
///
/// Panics if `position` is beyond the end of the string.
#[inline]
- pub fn ascii_byte_at(&self, position: uint) -> u8 {
+ pub fn ascii_byte_at(&self, position: usize) -> u8 {
match self.bytes[position] {
ascii_byte @ 0x00 ... 0x7F => ascii_byte,
_ => 0xFF
/// Panics if `position` is not at a code point boundary,
/// or is beyond the end of the string.
#[inline]
- pub fn code_point_at(&self, position: uint) -> CodePoint {
+ pub fn code_point_at(&self, position: usize) -> CodePoint {
let (code_point, _) = self.code_point_range_at(position);
code_point
}
/// Panics if `position` is not at a code point boundary,
/// or is beyond the end of the string.
#[inline]
- pub fn code_point_range_at(&self, position: uint) -> (CodePoint, uint) {
+ pub fn code_point_range_at(&self, position: usize) -> (CodePoint, usize) {
let (c, n) = char_range_at_raw(&self.bytes, position);
(CodePoint { value: c }, n)
}
}
#[inline]
- fn next_surrogate(&self, mut pos: uint) -> Option<(uint, u16)> {
+ fn next_surrogate(&self, mut pos: usize) -> Option<(usize, u16)> {
let mut iter = self.bytes[pos..].iter();
loop {
let b = match iter.next() {
///
/// Panics when `begin` and `end` do not point to code point boundaries,
/// or point beyond the end of the string.
-#[cfg(stage0)]
-impl ops::Index<ops::Range<usize>> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, range: &ops::Range<usize>) -> &Wtf8 {
- // is_code_point_boundary checks that the index is in [0, .len()]
- if range.start <= range.end &&
- is_code_point_boundary(self, range.start) &&
- is_code_point_boundary(self, range.end) {
- unsafe { slice_unchecked(self, range.start, range.end) }
- } else {
- slice_error_fail(self, range.start, range.end)
- }
- }
-}
-
-/// Return a slice of the given string for the byte range [`begin`..`end`).
-///
-/// # Panics
-///
-/// Panics when `begin` and `end` do not point to code point boundaries,
-/// or point beyond the end of the string.
-#[cfg(not(stage0))]
impl ops::Index<ops::Range<usize>> for Wtf8 {
type Output = Wtf8;
///
/// Panics when `begin` is not at a code point boundary,
/// or is beyond the end of the string.
-#[cfg(stage0)]
-impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, range: &ops::RangeFrom<usize>) -> &Wtf8 {
- // is_code_point_boundary checks that the index is in [0, .len()]
- if is_code_point_boundary(self, range.start) {
- unsafe { slice_unchecked(self, range.start, self.len()) }
- } else {
- slice_error_fail(self, range.start, self.len())
- }
- }
-}
-
-/// Return a slice of the given string from byte `begin` to its end.
-///
-/// # Panics
-///
-/// Panics when `begin` is not at a code point boundary,
-/// or is beyond the end of the string.
-#[cfg(not(stage0))]
impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
type Output = Wtf8;
///
/// Panics when `end` is not at a code point boundary,
/// or is beyond the end of the string.
-#[cfg(stage0)]
-impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, range: &ops::RangeTo<usize>) -> &Wtf8 {
- // is_code_point_boundary checks that the index is in [0, .len()]
- if is_code_point_boundary(self, range.end) {
- unsafe { slice_unchecked(self, 0, range.end) }
- } else {
- slice_error_fail(self, 0, range.end)
- }
- }
-}
-
-/// Return a slice of the given string from its beginning to byte `end`.
-///
-/// # Panics
-///
-/// Panics when `end` is not at a code point boundary,
-/// or is beyond the end of the string.
-#[cfg(not(stage0))]
impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
type Output = Wtf8;
}
}
-#[cfg(stage0)]
-impl ops::Index<ops::RangeFull> for Wtf8 {
- type Output = Wtf8;
-
- #[inline]
- fn index(&self, _range: &ops::RangeFull) -> &Wtf8 {
- self
- }
-}
-
-#[cfg(not(stage0))]
impl ops::Index<ops::RangeFull> for Wtf8 {
type Output = Wtf8;
/// Copied from core::str::StrPrelude::is_char_boundary
#[inline]
-pub fn is_code_point_boundary(slice: &Wtf8, index: uint) -> bool {
+pub fn is_code_point_boundary(slice: &Wtf8, index: usize) -> bool {
if index == slice.len() { return true; }
match slice.bytes.get(index) {
None => false,
/// Copied from core::str::raw::slice_unchecked
#[inline]
-pub unsafe fn slice_unchecked(s: &Wtf8, begin: uint, end: uint) -> &Wtf8 {
+pub unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 {
// memory layout of an &[u8] and &Wtf8 are the same
mem::transmute(slice::from_raw_parts(
- s.bytes.as_ptr().offset(begin as int),
+ s.bytes.as_ptr().offset(begin as isize),
end - begin
))
}
/// Copied from core::str::raw::slice_error_fail
#[inline(never)]
-pub fn slice_error_fail(s: &Wtf8, begin: uint, end: uint) -> ! {
+pub fn slice_error_fail(s: &Wtf8, begin: usize, end: usize) -> ! {
assert!(begin <= end);
panic!("index {} and/or {} in `{:?}` do not lie on character boundary",
begin, end, s);
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let (len, _) = self.bytes.size_hint();
(len.saturating_add(3) / 4, Some(len))
}
}
#[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
let (low, high) = self.code_points.size_hint();
// every code point gets either one u16 or two u16,
// so this iterator is between 1 or 2 times as
try!(writeln!(w, "stack backtrace:"));
// 100 lines should be enough
- const SIZE: uint = 100;
+ const SIZE: usize = 100;
let mut buf: [*mut libc::c_void; SIZE] = unsafe {mem::zeroed()};
- let cnt = unsafe { backtrace(buf.as_mut_ptr(), SIZE as libc::c_int) as uint};
+ let cnt = unsafe { backtrace(buf.as_mut_ptr(), SIZE as libc::c_int) as usize};
// skipping the first one as it is write itself
let iter = (1..cnt).map(|i| {
- print(w, i as int, buf[i], buf[i])
+ print(w, i as isize, buf[i], buf[i])
});
result::fold(iter, (), |_, _| ())
}
// tracing
pub fn write(w: &mut Write) -> io::Result<()> {
struct Context<'a> {
- idx: int,
+ idx: isize,
writer: &'a mut (Write+'a),
last_error: Option<io::Error>,
}
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
-fn print(w: &mut Write, idx: int, addr: *mut libc::c_void,
+fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void,
_symaddr: *mut libc::c_void) -> io::Result<()> {
use intrinsics;
#[repr(C)]
}
#[cfg(not(any(target_os = "macos", target_os = "ios")))]
-fn print(w: &mut Write, idx: int, addr: *mut libc::c_void,
+fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void,
symaddr: *mut libc::c_void) -> io::Result<()> {
use env;
use ffi::AsOsStr;
}
// Finally, after all that work above, we can emit a symbol.
-fn output(w: &mut Write, idx: int, addr: *mut libc::c_void,
+fn output(w: &mut Write, idx: isize, addr: *mut libc::c_void,
s: Option<&[u8]>) -> io::Result<()> {
try!(write!(w, " {:2}: {:2$?} - ", idx, addr, HEX_WIDTH));
match s.and_then(|s| str::from_utf8(s).ok()) {
#[cfg(any(target_os = "macos", target_os = "ios"))]
mod select {
- pub const FD_SETSIZE: uint = 1024;
+ pub const FD_SETSIZE: usize = 1024;
#[repr(C)]
pub struct fd_set {
}
pub fn fd_set(set: &mut fd_set, fd: i32) {
- set.fds_bits[(fd / 32) as uint] |= 1 << ((fd % 32) as uint);
+ set.fds_bits[(fd / 32) as usize] |= 1 << ((fd % 32) as usize);
}
}
}
pub fn fd_set(set: &mut fd_set, fd: i32) {
- let fd = fd as uint;
+ let fd = fd as usize;
set.fds_bits[fd / usize::BITS as usize] |= 1 << (fd % usize::BITS as usize);
}
}
FileDesc { fd: fd, close_on_drop: close_on_drop }
}
- pub fn read(&self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&self, buf: &mut [u8]) -> IoResult<usize> {
let ret = retry(|| unsafe {
libc::read(self.fd(),
buf.as_mut_ptr() as *mut libc::c_void,
} else if ret < 0 {
Err(super::last_error())
} else {
- Ok(ret as uint)
+ Ok(ret as usize)
}
}
pub fn write(&self, buf: &[u8]) -> IoResult<()> {
}
}
-pub fn mkdir(p: &Path, mode: uint) -> IoResult<()> {
+pub fn mkdir(p: &Path, mode: usize) -> IoResult<()> {
let p = try!(cstr(p));
mkerr_libc(unsafe { libc::mkdir(p.as_ptr(), mode as libc::mode_t) })
}
}
let size = unsafe { rust_dirent_t_size() };
- let mut buf = Vec::<u8>::with_capacity(size as uint);
+ let mut buf = Vec::<u8>::with_capacity(size as usize);
let ptr = buf.as_mut_ptr() as *mut dirent_t;
let p = try!(CString::new(p.as_vec()));
let dir_ptr = unsafe {opendir(p.as_ptr())};
- if dir_ptr as uint != 0 {
+ if dir_ptr as usize != 0 {
let mut paths = vec!();
let mut entry_ptr = ptr::null_mut();
while unsafe { readdir_r(dir_ptr, ptr, &mut entry_ptr) == 0 } {
})
}
-pub fn chmod(p: &Path, mode: uint) -> IoResult<()> {
+pub fn chmod(p: &Path, mode: usize) -> IoResult<()> {
let p = try!(cstr(p));
mkerr_libc(retry(|| unsafe {
libc::chmod(p.as_ptr(), mode as libc::mode_t)
mkerr_libc(unsafe { libc::rmdir(p.as_ptr()) })
}
-pub fn chown(p: &Path, uid: int, gid: int) -> IoResult<()> {
+pub fn chown(p: &Path, uid: isize, gid: isize) -> IoResult<()> {
let p = try!(cstr(p));
mkerr_libc(retry(|| unsafe {
libc::chown(p.as_ptr(), uid as libc::uid_t, gid as libc::gid_t)
if len == -1 {
len = 1024; // FIXME: read PATH_MAX from C ffi?
}
- let mut buf: Vec<u8> = Vec::with_capacity(len as uint);
+ let mut buf: Vec<u8> = Vec::with_capacity(len as usize);
match unsafe {
libc::readlink(p, buf.as_ptr() as *mut libc::c_char,
len as libc::size_t) as libc::c_int
-1 => Err(super::last_error()),
n => {
assert!(n > 0);
- unsafe { buf.set_len(n as uint); }
+ unsafe { buf.set_len(n as usize); }
Ok(Path::new(buf))
}
}
}
}
+#[allow(deprecated)]
pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> {
let one: T = Int::one();
if t == -one {
}
}
+#[allow(deprecated)]
pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
where T: SignedInt, F: FnMut() -> T
{
0 as libc::size_t);
if err != 0 { return Err(io::Error::last_os_error()); }
if sz == 0 { return Err(io::Error::last_os_error()); }
- let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
+ let mut v: Vec<u8> = Vec::with_capacity(sz as usize);
let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
v.as_mut_ptr() as *mut libc::c_void, &mut sz,
ptr::null_mut(), 0 as libc::size_t);
if err != 0 { return Err(io::Error::last_os_error()); }
if sz == 0 { return Err(io::Error::last_os_error()); }
- v.set_len(sz as uint - 1); // chop off trailing NUL
+ v.set_len(sz as usize - 1); // chop off trailing NUL
Ok(PathBuf::from(OsString::from_vec(v)))
}
}
let mut sz: u32 = 0;
_NSGetExecutablePath(ptr::null_mut(), &mut sz);
if sz == 0 { return Err(io::Error::last_os_error()); }
- let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
+ let mut v: Vec<u8> = Vec::with_capacity(sz as usize);
let err = _NSGetExecutablePath(v.as_mut_ptr() as *mut i8, &mut sz);
if err != 0 { return Err(io::Error::last_os_error()); }
- v.set_len(sz as uint - 1); // chop off trailing NUL
+ v.set_len(sz as usize - 1); // chop off trailing NUL
Ok(PathBuf::from(OsString::from_vec(v)))
}
}
let info = objc_msgSend(klass, process_info_sel);
let args = objc_msgSend(info, arguments_sel);
- let cnt: int = mem::transmute(objc_msgSend(args, count_sel));
+ let cnt: usize = mem::transmute(objc_msgSend(args, count_sel));
for i in (0..cnt) {
let tmp = objc_msgSend(args, object_at_sel, i);
let utf_c_str: *const libc::c_char =
Buf { inner: s.into_bytes() }
}
- pub fn from_str(s: &str) -> Buf {
- Buf { inner: s.as_bytes().to_vec() }
- }
-
pub fn as_slice(&self) -> &Slice {
unsafe { mem::transmute(&*self.inner) }
}
ret
}
- pub fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
let fd = self.fd();
let dolock = || self.lock_nonblocking();
let doread = |nb| unsafe {
pub fn write(&mut self, buf: &[u8]) -> IoResult<()> {
let fd = self.fd();
let dolock = || self.lock_nonblocking();
- let dowrite = |nb: bool, buf: *const u8, len: uint| unsafe {
+ let dowrite = |nb: bool, buf: *const u8, len: usize| unsafe {
let flags = if nb {c::MSG_DONTWAIT} else {0};
libc::send(fd,
buf as *const _,
self.pid
}
- pub unsafe fn kill(&self, signal: int) -> IoResult<()> {
+ pub unsafe fn kill(&self, signal: isize) -> IoResult<()> {
Process::killpid(self.pid, signal)
}
- pub unsafe fn killpid(pid: pid_t, signal: int) -> IoResult<()> {
+ pub unsafe fn killpid(pid: pid_t, signal: isize) -> IoResult<()> {
let r = libc::funcs::posix88::signal::kill(pid, signal as c_int);
mkerr_libc(r)
}
// with process timeouts, but libgreen should get there first
// (currently libuv doesn't handle old signal handlers).
if drain(read_fd) {
- let i: uint = unsafe { mem::transmute(old.sa_handler) };
+ let i: usize = unsafe { mem::transmute(old.sa_handler) };
if i != 0 {
assert!(old.sa_flags & c::SA_SIGINFO == 0);
(old.sa_handler)(c::SIGCHLD);
}
if imp::WIFEXITED(status) {
- ExitStatus(imp::WEXITSTATUS(status) as int)
+ ExitStatus(imp::WEXITSTATUS(status) as isize)
} else {
- ExitSignal(imp::WTERMSIG(status) as int)
+ ExitSignal(imp::WTERMSIG(status) as isize)
}
}
// This is initialized in init() and only read from after
- static mut PAGE_SIZE: uint = 0;
+ static mut PAGE_SIZE: usize = 0;
#[no_stack_check]
unsafe extern fn signal_handler(signum: libc::c_int,
stack::record_sp_limit(0);
let guard = thread_info::stack_guard();
- let addr = (*info).si_addr as uint;
+ let addr = (*info).si_addr as usize;
if guard == 0 || addr < guard - PAGE_SIZE || addr >= guard {
term(signum);
panic!("failed to get page size");
}
- PAGE_SIZE = psize as uint;
+ PAGE_SIZE = psize as usize;
let mut action: sigaction = mem::zeroed();
action.sa_flags = SA_SIGINFO | SA_ONSTACK;
#[cfg(any(target_arch = "x86_64",
target_arch = "aarch64"))]
- const __PTHREAD_MUTEX_SIZE__: uint = 56;
+ const __PTHREAD_MUTEX_SIZE__: usize = 56;
#[cfg(any(target_arch = "x86",
target_arch = "arm"))]
- const __PTHREAD_MUTEX_SIZE__: uint = 40;
+ const __PTHREAD_MUTEX_SIZE__: usize = 40;
#[cfg(any(target_arch = "x86_64",
target_arch = "aarch64"))]
- const __PTHREAD_COND_SIZE__: uint = 40;
+ const __PTHREAD_COND_SIZE__: usize = 40;
#[cfg(any(target_arch = "x86",
target_arch = "arm"))]
- const __PTHREAD_COND_SIZE__: uint = 24;
+ const __PTHREAD_COND_SIZE__: usize = 24;
#[cfg(any(target_arch = "x86_64",
target_arch = "aarch64"))]
- const __PTHREAD_RWLOCK_SIZE__: uint = 192;
+ const __PTHREAD_RWLOCK_SIZE__: usize = 192;
#[cfg(any(target_arch = "x86",
target_arch = "arm"))]
- const __PTHREAD_RWLOCK_SIZE__: uint = 124;
+ const __PTHREAD_RWLOCK_SIZE__: usize = 124;
const _PTHREAD_MUTEX_SIG_INIT: libc::c_long = 0x32AAABA7;
const _PTHREAD_COND_SIG_INIT: libc::c_long = 0x3CB0B1BB;
// minus 8 because we have an 'align' field
#[cfg(target_arch = "x86_64")]
- const __SIZEOF_PTHREAD_MUTEX_T: uint = 40 - 8;
+ const __SIZEOF_PTHREAD_MUTEX_T: usize = 40 - 8;
#[cfg(any(target_arch = "x86",
target_arch = "arm",
target_arch = "mips",
target_arch = "mipsel",
target_arch = "powerpc"))]
- const __SIZEOF_PTHREAD_MUTEX_T: uint = 24 - 8;
+ const __SIZEOF_PTHREAD_MUTEX_T: usize = 24 - 8;
#[cfg(target_arch = "aarch64")]
- const __SIZEOF_PTHREAD_MUTEX_T: uint = 48 - 8;
+ const __SIZEOF_PTHREAD_MUTEX_T: usize = 48 - 8;
#[cfg(any(target_arch = "x86_64",
target_arch = "x86",
target_arch = "mips",
target_arch = "mipsel",
target_arch = "powerpc"))]
- const __SIZEOF_PTHREAD_COND_T: uint = 48 - 8;
+ const __SIZEOF_PTHREAD_COND_T: usize = 48 - 8;
#[cfg(any(target_arch = "x86_64",
target_arch = "aarch64"))]
- const __SIZEOF_PTHREAD_RWLOCK_T: uint = 56 - 8;
+ const __SIZEOF_PTHREAD_RWLOCK_T: usize = 56 - 8;
#[cfg(any(target_arch = "x86",
target_arch = "arm",
target_arch = "mips",
target_arch = "mipsel",
target_arch = "powerpc"))]
- const __SIZEOF_PTHREAD_RWLOCK_T: uint = 32 - 8;
+ const __SIZEOF_PTHREAD_RWLOCK_T: usize = 32 - 8;
#[repr(C)]
pub struct pthread_mutex_t {
pub fn fd(&self) -> sock_t { self.inner.fd() }
- pub fn listen(self, backlog: int) -> IoResult<TcpAcceptor> {
+ pub fn listen(self, backlog: isize) -> IoResult<TcpAcceptor> {
match unsafe { libc::listen(self.fd(), backlog as libc::c_int) } {
-1 => Err(last_net_error()),
_ => {
}
pub struct Timer {
- id: uint,
+ id: usize,
inner: Option<Box<Inner>>,
}
interval: u64,
repeat: bool,
target: u64,
- id: uint,
+ id: usize,
}
pub enum Req {
// Remove a timer based on its id and then send it back on the channel
// provided
- RemoveTimer(uint, Sender<Box<Inner>>),
+ RemoveTimer(usize, Sender<Box<Inner>>),
}
// returns the current time (in milliseconds)
// signals the first requests in the queue, possible re-enqueueing it.
fn signal(active: &mut Vec<Box<Inner>>,
- dead: &mut Vec<(uint, Box<Inner>)>) {
+ dead: &mut Vec<(usize, Box<Inner>)>) {
if active.is_empty() { return }
let mut timer = active.remove(0);
impl Timer {
pub fn new() -> IoResult<Timer> {
- // See notes above regarding using int return value
+ // See notes above regarding using isize return value
// instead of ()
HELPER.boot(|| {}, helper);
tv_nsec: ((ms % 1000) * 1000000) as libc::c_long,
};
while unsafe { libc::nanosleep(&to_sleep, &mut to_sleep) } != 0 {
- if os::errno() as int != libc::EINTR as int {
+ if os::errno() as isize != libc::EINTR as isize {
panic!("failed to sleep, but not because of EINTR?");
}
}
}
}
- pub fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
self.fd.read(buf)
}
pub fn write(&mut self, buf: &[u8]) -> IoResult<()> {
Err(sys_common::unimpl())
}
- pub fn get_winsize(&mut self) -> IoResult<(int, int)> {
+ pub fn get_winsize(&mut self) -> IoResult<(isize, isize)> {
unsafe {
#[repr(C)]
struct winsize {
detail: None,
})
} else {
- Ok((size.ws_col as int, size.ws_row as int))
+ Ok((size.ws_col as isize, size.ws_row as isize))
}
}
}
//! this takes the route of using StackWalk64 in order to walk the stack.
#![allow(dead_code)]
-#![allow(deprecated)] // for old path for dynamic lib
use prelude::v1::*;
use io::prelude::*;
use io;
use libc;
use mem;
-use old_path::Path;
+use path::Path;
use ptr;
use str;
use sync::{StaticMutex, MUTEX_INIT};
*mut libc::c_void, *mut libc::c_void,
*mut libc::c_void, *mut libc::c_void) -> libc::BOOL;
-const MAX_SYM_NAME: uint = 2000;
+const MAX_SYM_NAME: usize = 2000;
const IMAGE_FILE_MACHINE_I386: libc::DWORD = 0x014c;
const IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200;
const IMAGE_FILE_MACHINE_AMD64: libc::DWORD = 0x8664;
mod arch {
use libc;
- const MAXIMUM_SUPPORTED_EXTENSION: uint = 512;
+ const MAXIMUM_SUPPORTED_EXTENSION: usize = 512;
#[repr(C)]
pub struct CONTEXT {
FileDesc { fd: fd, close_on_drop: close_on_drop }
}
- pub fn read(&self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&self, buf: &mut [u8]) -> IoResult<usize> {
let mut read = 0;
let ret = unsafe {
libc::ReadFile(self.handle(), buf.as_ptr() as libc::LPVOID,
ptr::null_mut())
};
if ret != 0 {
- Ok(read as uint)
+ Ok(read as usize)
} else {
Err(super::last_error())
}
ptr::null_mut())
};
if ret != 0 {
- remaining -= amt as uint;
- cur = unsafe { cur.offset(amt as int) };
+ remaining -= amt as usize;
+ cur = unsafe { cur.offset(amt as isize) };
} else {
return Err(super::last_error())
}
}
}
-pub fn mkdir(p: &Path, _mode: uint) -> IoResult<()> {
+pub fn mkdir(p: &Path, _mode: usize) -> IoResult<()> {
let p = try!(to_utf16(p));
super::mkerr_winbool(unsafe {
// FIXME: turn mode into something useful? #2623
};
if stat.perm.intersects(old_io::USER_WRITE) { return Err(e) }
- match chmod(p, (stat.perm | old_io::USER_WRITE).bits() as uint) {
+ match chmod(p, (stat.perm | old_io::USER_WRITE).bits() as usize) {
Ok(()) => do_unlink(&p_utf16),
Err(..) => {
// Try to put it back as we found it
- let _ = chmod(p, stat.perm.bits() as uint);
+ let _ = chmod(p, stat.perm.bits() as usize);
Err(e)
}
}
})
}
-pub fn chmod(p: &Path, mode: uint) -> IoResult<()> {
+pub fn chmod(p: &Path, mode: usize) -> IoResult<()> {
let p = try!(to_utf16(p));
mkerr_libc(unsafe {
libc::wchmod(p.as_ptr(), mode as libc::c_int)
super::mkerr_winbool(unsafe { libc::RemoveDirectoryW(p.as_ptr()) })
}
-pub fn chown(_p: &Path, _uid: int, _gid: int) -> IoResult<()> {
+pub fn chown(_p: &Path, _uid: isize, _gid: isize) -> IoResult<()> {
// libuv has this as a no-op, so seems like this should as well?
Ok(())
}
use io::{self, ErrorKind};
use libc;
use mem;
+#[allow(deprecated)]
use num::Int;
use old_io::{self, IoResult, IoError};
use os::windows::ffi::{OsStrExt, OsStringExt};
}
}
+#[allow(deprecated)]
fn cvt<I: Int>(i: I) -> io::Result<I> {
if i == Int::zero() {
Err(io::Error::last_os_error())
use libc::{self, c_int, c_void};
use mem;
use net::SocketAddr;
+#[allow(deprecated)]
use num::{SignedInt, Int};
use rt;
use sync::{Once, ONCE_INIT};
/// function must be called before another call to the socket API is made.
///
/// FIXME: generics needed?
+#[allow(deprecated)]
pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> {
let one: T = Int::one();
if t == -one {
}
/// Provides the functionality of `cvt` for a closure.
+#[allow(deprecated)]
pub fn cvt_r<T: SignedInt, F>(mut f: F) -> io::Result<T> where F: FnMut() -> T {
cvt(f())
}
Buf { inner: Wtf8Buf::from_string(s) }
}
- pub fn from_str(s: &str) -> Buf {
- Buf { inner: Wtf8Buf::from_str(s) }
- }
-
pub fn as_slice(&self) -> &Slice {
unsafe { mem::transmute(self.inner.as_slice()) }
}
initial_state as libc::BOOL,
ptr::null())
};
- if event as uint == 0 {
+ if event as usize == 0 {
Err(super::last_error())
} else {
Ok(Event(event))
}
pub fn await(handle: libc::HANDLE, deadline: u64,
- events: &[libc::HANDLE]) -> IoResult<uint> {
+ events: &[libc::HANDLE]) -> IoResult<usize> {
use libc::consts::os::extra::{WAIT_FAILED, WAIT_TIMEOUT, WAIT_OBJECT_0};
// If we've got a timeout, use WaitForSingleObject in tandem with CancelIo
let _ = c::CancelIo(handle);
Err(sys_common::timeout("operation timed out"))
},
- n => Ok((n - WAIT_OBJECT_0) as uint)
+ n => Ok((n - WAIT_OBJECT_0) as usize)
}
}
// `WaitNamedPipe` function, and this is indicated with an error
// code of ERROR_PIPE_BUSY.
let code = unsafe { libc::GetLastError() };
- if code as int != libc::ERROR_PIPE_BUSY as int {
+ if code as isize != libc::ERROR_PIPE_BUSY as isize {
return Err(super::last_error())
}
}
}
- pub fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
if self.read.is_none() {
self.read = Some(try!(Event::new(true, false)));
}
&mut bytes_read,
&mut overlapped)
};
- if ret != 0 { return Ok(bytes_read as uint) }
+ if ret != 0 { return Ok(bytes_read as usize) }
// If our errno doesn't say that the I/O is pending, then we hit some
// legitimate error and return immediately.
};
// If we succeeded, or we failed for some reason other than
// CancelIoEx, return immediately
- if ret != 0 { return Ok(bytes_read as uint) }
+ if ret != 0 { return Ok(bytes_read as usize) }
if os::errno() != libc::ERROR_OPERATION_ABORTED as i32 {
return Err(super::last_error())
}
return Err(super::last_error())
}
if !wait_succeeded.is_ok() {
- let amt = offset + bytes_written as uint;
+ let amt = offset + bytes_written as usize;
return if amt > 0 {
Err(IoError {
kind: old_io::ShortWrite(amt),
continue // retry
}
}
- offset += bytes_written as uint;
+ offset += bytes_written as usize;
}
Ok(())
}
self.pid
}
- pub unsafe fn kill(&self, signal: int) -> IoResult<()> {
+ pub unsafe fn kill(&self, signal: isize) -> IoResult<()> {
Process::killpid(self.pid, signal)
}
- pub unsafe fn killpid(pid: pid_t, signal: int) -> IoResult<()> {
+ pub unsafe fn killpid(pid: pid_t, signal: isize) -> IoResult<()> {
let handle = libc::OpenProcess(libc::PROCESS_TERMINATE |
libc::PROCESS_QUERY_INFORMATION,
libc::FALSE, pid as libc::DWORD);
}
if status != STILL_ACTIVE {
assert!(CloseHandle(process) != 0);
- return Ok(ExitStatus(status as int));
+ return Ok(ExitStatus(status as isize));
}
let interval = if deadline == 0 {
INFINITE
}
}
- fn append_char_at(cmd: &mut String, arg: &[char], i: uint) {
+ fn append_char_at(cmd: &mut String, arg: &[char], i: usize) {
match arg[i] {
'"' => {
// Escape quotes.
}
}
- fn backslash_run_ends_in_quote(s: &[char], mut i: uint) -> bool {
+ fn backslash_run_ends_in_quote(s: &[char], mut i: usize) -> bool {
while i < s.len() && s[i] == '\\' {
i += 1;
}
use env::split_paths;
use mem;
- use iter::IteratorExt;
+ use iter::Iterator;
// To have the spawning semantics of unix/windows stay the same, we need to
// read the *child's* PATH if one is provided. See #15149 for more details.
}
// This is initialized in init() and only read from after
-static mut PAGE_SIZE: uint = 0;
+static mut PAGE_SIZE: usize = 0;
#[no_stack_check]
extern "system" fn vectored_handler(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG {
pub unsafe fn init() {
let mut info = mem::zeroed();
libc::GetSystemInfo(&mut info);
- PAGE_SIZE = info.dwPageSize as uint;
+ PAGE_SIZE = info.dwPageSize as usize;
if AddVectoredExceptionHandler(0, vectored_handler) == ptr::null_mut() {
panic!("failed to install exception handler");
pub type ULONG = libc::c_ulong;
const EXCEPTION_CONTINUE_SEARCH: LONG = 0;
-const EXCEPTION_MAXIMUM_PARAMETERS: uint = 15;
+const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15;
const EXCEPTION_STACK_OVERFLOW: DWORD = 0xc00000fd;
extern "system" {
pub fn socket(&self) -> sock_t { self.sock }
- pub fn listen(self, backlog: int) -> IoResult<TcpAcceptor> {
+ pub fn listen(self, backlog: isize) -> IoResult<TcpAcceptor> {
match unsafe { libc::listen(self.socket(), backlog as libc::c_int) } {
-1 => Err(last_net_error()),
pub type rust_thread = HANDLE;
pub mod guard {
- pub unsafe fn main() -> uint { 0 }
- pub unsafe fn current() -> uint { 0 }
+ pub unsafe fn main() -> usize { 0 }
+ pub unsafe fn current() -> usize { 0 }
pub unsafe fn init() {}
}
let dtors = DTORS;
DTORS = 1 as *mut _;
Box::from_raw(dtors);
- assert!(DTORS as uint == 1); // can't re-init after destructing
+ assert!(DTORS as usize == 1); // can't re-init after destructing
DTOR_LOCK.unlock();
});
if res.is_ok() {
unsafe fn register_dtor(key: Key, dtor: Dtor) {
DTOR_LOCK.lock();
init_dtors();
- assert!(DTORS as uint != 0);
- assert!(DTORS as uint != 1,
+ assert!(DTORS as usize != 0);
+ assert!(DTORS as usize != 1,
"cannot create new TLS keys after the main thread has exited");
(*DTORS).push((key, dtor));
DTOR_LOCK.unlock();
unsafe fn unregister_dtor(key: Key) -> bool {
DTOR_LOCK.lock();
init_dtors();
- assert!(DTORS as uint != 0);
- assert!(DTORS as uint != 1,
+ assert!(DTORS as usize != 0);
+ assert!(DTORS as usize != 1,
"cannot unregister destructors after the main thread has exited");
let ret = {
let dtors = &mut *DTORS;
}
} else {
let remove = {
- match &mut chans[idx as uint - 1] {
+ match &mut chans[idx as usize - 1] {
&mut (ref mut c, oneshot) => { c.call(); oneshot }
}
};
if remove {
- drop(objs.remove(idx as uint));
- drop(chans.remove(idx as uint - 1));
+ drop(objs.remove(idx as usize));
+ drop(chans.remove(idx as usize - 1));
}
}
}
use super::c::{ENABLE_PROCESSED_INPUT, ENABLE_QUICK_EDIT_MODE};
use super::c::CONSOLE_SCREEN_BUFFER_INFO;
use super::c::{ReadConsoleW, WriteConsoleW, GetConsoleMode, SetConsoleMode};
-use super::c::{GetConsoleScreenBufferInfo};
+use super::c::GetConsoleScreenBufferInfo;
fn invalid_encoding() -> IoError {
IoError {
}
}
- pub fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
+ pub fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
// Read more if the buffer is empty
if self.utf8.eof() {
let mut utf16: Vec<u16> = repeat(0u16).take(0x1000).collect();
0 => return Err(super::last_error()),
_ => (),
};
- utf16.truncate(num as uint);
+ utf16.truncate(num as usize);
let utf8 = match String::from_utf16(&utf16) {
Ok(utf8) => utf8.into_bytes(),
Err(..) => return Err(invalid_encoding()),
}
}
- pub fn get_winsize(&mut self) -> IoResult<(int, int)> {
+ pub fn get_winsize(&mut self) -> IoResult<(isize, isize)> {
let mut info: CONSOLE_SCREEN_BUFFER_INFO = unsafe { mem::zeroed() };
match unsafe { GetConsoleScreenBufferInfo(self.handle, &mut info as *mut _) } {
0 => Err(super::last_error()),
- _ => Ok(((info.srWindow.Right + 1 - info.srWindow.Left) as int,
- (info.srWindow.Bottom + 1 - info.srWindow.Top) as int)),
+ _ => Ok(((info.srWindow.Right + 1 - info.srWindow.Left) as isize,
+ (info.srWindow.Bottom + 1 - info.srWindow.Top) as isize)),
}
}
}
unwind::panicking()
}
+/// Invoke a closure, capturing the cause of panic if one occurs.
+///
+/// This function will return `Ok(())` if the closure does not panic, and will
+/// return `Err(cause)` if the closure panics. The `cause` returned is the
+/// object with which panic was originally invoked.
+///
+/// It is currently undefined behavior to unwind from Rust code into foreign
+/// code, so this function is particularly useful when Rust is called from
+/// another language (normally C). This can run arbitrary Rust code, capturing a
+/// panic and allowing a graceful handling of the error.
+///
+/// It is **not** recommended to use this function for a general try/catch
+/// mechanism. The `Result` type is more appropriate to use for functions that
+/// can fail on a regular basis.
+///
+/// The closure provided is required to adhere to the `'static` bound to ensure
+/// that it cannot reference data in the parent stack frame, mitigating problems
+/// with exception safety. Furthermore, a `Send` bound is also required,
+/// providing the same safety guarantees as `thread::spawn` (ensuring the
+/// closure is properly isolated from the parent).
+///
+/// # Examples
+///
+/// ```
+/// # #![feature(catch_panic)]
+/// use std::thread;
+///
+/// let result = thread::catch_panic(|| {
+/// println!("hello!");
+/// });
+/// assert!(result.is_ok());
+///
+/// let result = thread::catch_panic(|| {
+/// panic!("oh no!");
+/// });
+/// assert!(result.is_err());
+/// ```
+#[unstable(feature = "catch_panic", reason = "recent API addition")]
+pub fn catch_panic<F, R>(f: F) -> Result<R>
+ where F: FnOnce() -> R + Send + 'static
+{
+ let mut result = None;
+ unsafe {
+ let result = &mut result;
+ try!(::rt::unwind::try(move || *result = Some(f())))
+ }
+ Ok(result.unwrap())
+}
+
/// Put the current thread to sleep for the specified amount of time.
///
/// The thread may sleep longer than the duration specified due to scheduling
}
#[test]
- #[should_fail]
+ #[should_panic]
fn test_scoped_panic() {
thread::scoped(|| panic!()).join();
}
#[test]
- #[should_fail]
+ #[should_panic]
fn test_scoped_implicit_panic() {
let _ = thread::scoped(|| panic!());
}
use ops::{Add, Sub, Mul, Div, Neg, FnOnce};
use option::Option;
use option::Option::{Some, None};
+#[allow(deprecated)] // Int
use num::Int;
use result::Result::Ok;
use ptr::P;
use std::fmt;
+#[allow(deprecated)]
use std::num::Int;
use std::rc::Rc;
use serialize::{Encodable, Decodable, Encoder, Decoder};
}
impl Sign {
+ #[allow(deprecated)] // Int
pub fn new<T:Int>(n: T) -> Sign {
if n < Int::zero() {
Minus
MacImplItem(Mac),
}
-#[derive(Clone, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum IntTy {
- TyIs(bool /* is this deprecated `int`? */),
+ TyIs,
TyI8,
TyI16,
TyI32,
TyI64,
}
-impl PartialEq for IntTy {
- fn eq(&self, other: &IntTy) -> bool {
- match (*self, *other) {
- // true/false need to compare the same, so this can't be derived
- (TyIs(_), TyIs(_)) |
- (TyI8, TyI8) |
- (TyI16, TyI16) |
- (TyI32, TyI32) |
- (TyI64, TyI64) => true,
- _ => false
- }
- }
-}
-
impl fmt::Debug for IntTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(self, f)
impl IntTy {
pub fn suffix_len(&self) -> usize {
match *self {
- TyIs(true) /* i */ => 1,
- TyIs(false) /* is */ | TyI8 => 2,
+ TyIs | TyI8 => 2,
TyI16 | TyI32 | TyI64 => 3,
}
}
}
-#[derive(Clone, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
+#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)]
pub enum UintTy {
- TyUs(bool /* is this deprecated uint? */),
+ TyUs,
TyU8,
TyU16,
TyU32,
TyU64,
}
-impl PartialEq for UintTy {
- fn eq(&self, other: &UintTy) -> bool {
- match (*self, *other) {
- // true/false need to compare the same, so this can't be derived
- (TyUs(_), TyUs(_)) |
- (TyU8, TyU8) |
- (TyU16, TyU16) |
- (TyU32, TyU32) |
- (TyU64, TyU64) => true,
- _ => false
- }
- }
-}
-
impl UintTy {
pub fn suffix_len(&self) -> usize {
match *self {
- TyUs(true) /* u */ => 1,
- TyUs(false) /* us */ | TyU8 => 2,
+ TyUs | TyU8 => 2,
TyU16 | TyU32 | TyU64 => 3,
}
}
use abi;
use ast::{Block, FnDecl, NodeId};
use ast;
-use ast_map::{Node};
+use ast_map::Node;
use ast_map;
use codemap::Span;
use visit;
pub fn is_comparison_binop(b: BinOp_) -> bool {
match b {
- BiEq | BiLt | BiLe | BiNe | BiGt | BiGe => true,
- _ => false
+ BiEq | BiLt | BiLe | BiNe | BiGt | BiGe =>
+ true,
+ BiAnd | BiOr | BiAdd | BiSub | BiMul | BiDiv | BiRem |
+ BiBitXor | BiBitAnd | BiBitOr | BiShl | BiShr =>
+ false,
}
}
/// Returns `true` if the binary operator takes its arguments by value
pub fn is_by_value_binop(b: BinOp_) -> bool {
- match b {
- BiAdd | BiSub | BiMul | BiDiv | BiRem | BiBitXor | BiBitAnd | BiBitOr | BiShl | BiShr => {
- true
- }
- _ => false
- }
-}
-
-/// Returns `true` if the binary operator is symmetric in the sense that LHS
-/// and RHS must have the same type. So the type of LHS can serve as an hint
-/// for the type of RHS and vice versa.
-pub fn is_symmetric_binop(b: BinOp_) -> bool {
- match b {
- BiAdd | BiSub | BiMul | BiDiv | BiRem |
- BiBitXor | BiBitAnd | BiBitOr |
- BiEq | BiLt | BiLe | BiNe | BiGt | BiGe => {
- true
- }
- _ => false
- }
+ !is_comparison_binop(b)
}
/// Returns `true` if the unary operator takes its argument by value
/// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
pub fn int_ty_to_string(t: IntTy, val: Option<i64>) -> String {
let s = match t {
- TyIs(_) => "isize",
+ TyIs => "isize",
TyI8 => "i8",
TyI16 => "i16",
TyI32 => "i32",
match t {
TyI8 => 0x80,
TyI16 => 0x8000,
- TyIs(_) | TyI32 => 0x80000000, // actually ni about TyIs
+ TyIs | TyI32 => 0x80000000, // actually ni about TyIs
TyI64 => 0x8000000000000000
}
}
/// We want to avoid "42u" in favor of "42us". "42uint" is right out.
pub fn uint_ty_to_string(t: UintTy, val: Option<u64>) -> String {
let s = match t {
- TyUs(_) => "usize",
+ TyUs => "usize",
TyU8 => "u8",
TyU16 => "u16",
TyU32 => "u32",
match t {
TyU8 => 0xff,
TyU16 => 0xffff,
- TyUs(_) | TyU32 => 0xffffffff, // actually ni about TyUs
+ TyUs | TyU32 => 0xffffffff, // actually ni about TyUs
TyU64 => 0xffffffffffffffff
}
}
"u32" => Some(UnsignedInt(ast::TyU32)),
"i64" => Some(SignedInt(ast::TyI64)),
"u64" => Some(UnsignedInt(ast::TyU64)),
- "int" => Some(SignedInt(ast::TyIs(true))),
- "uint" => Some(UnsignedInt(ast::TyUs(true))),
- "isize" => Some(SignedInt(ast::TyIs(false))),
- "usize" => Some(UnsignedInt(ast::TyUs(false))),
+ "isize" => Some(SignedInt(ast::TyIs)),
+ "usize" => Some(UnsignedInt(ast::TyUs)),
_ => None
}
}
SignedInt(ast::TyI16) | UnsignedInt(ast::TyU16) |
SignedInt(ast::TyI32) | UnsignedInt(ast::TyU32) |
SignedInt(ast::TyI64) | UnsignedInt(ast::TyU64) => true,
- SignedInt(ast::TyIs(_)) | UnsignedInt(ast::TyUs(_)) => false
+ SignedInt(ast::TyIs) | UnsignedInt(ast::TyUs) => false
}
}
}
self.expr(sp, ast::ExprLit(P(respan(sp, lit))))
}
fn expr_usize(&self, span: Span, i: usize) -> P<ast::Expr> {
- self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs(false))))
+ self.expr_lit(span, ast::LitInt(i as u64, ast::UnsignedIntLit(ast::TyUs)))
}
fn expr_int(&self, sp: Span, i: isize) -> P<ast::Expr> {
- self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs(false),
+ self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs,
ast::Sign::new(i))))
}
fn expr_u32(&self, sp: Span, u: u32) -> P<ast::Expr> {
use ext::base;
use feature_gate;
use parse::token;
-use parse::token::{str_to_ident};
+use parse::token::str_to_ident;
use ptr::P;
pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
let arms: Vec<ast::Arm> = variants.iter().enumerate()
.map(|(index, variant)| {
let pat = variant_to_pat(cx, sp, type_ident, &**variant);
- let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs(false)));
+ let lit = ast::LitInt(index as u64, ast::UnsignedIntLit(ast::TyUs));
cx.arm(sp, vec![pat], cx.expr_lit(sp, lit))
}).collect();
use ast::{MetaItem, Item, Expr};
use codemap::Span;
use ext::base::ExtCtxt;
-use ext::build::{AstBuilder};
+use ext::build::AstBuilder;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use ptr::P;
(unsigned, $t:ty, $tag:expr) => (
impl ToSource for $t {
fn to_source(&self) -> String {
- #![allow(trivial_numeric_casts)]
let lit = ast::LitInt(*self as u64, ast::UnsignedIntLit($tag));
pprust::lit_to_string(&dummy_spanned(lit))
}
);
}
- impl_to_source_int! { signed, int, ast::TyIs(false) }
+ impl_to_source_int! { signed, isize, ast::TyIs }
impl_to_source_int! { signed, i8, ast::TyI8 }
impl_to_source_int! { signed, i16, ast::TyI16 }
impl_to_source_int! { signed, i32, ast::TyI32 }
impl_to_source_int! { signed, i64, ast::TyI64 }
- impl_to_source_int! { unsigned, uint, ast::TyUs(false) }
+ impl_to_source_int! { unsigned, usize, ast::TyUs }
impl_to_source_int! { unsigned, u8, ast::TyU8 }
impl_to_source_int! { unsigned, u16, ast::TyU16 }
impl_to_source_int! { unsigned, u32, ast::TyU32 }
impl_to_tokens! { () }
impl_to_tokens! { char }
impl_to_tokens! { bool }
- impl_to_tokens! { int }
+ impl_to_tokens! { isize }
impl_to_tokens! { i8 }
impl_to_tokens! { i16 }
impl_to_tokens! { i32 }
impl_to_tokens! { i64 }
- impl_to_tokens! { uint }
+ impl_to_tokens! { usize }
impl_to_tokens! { u8 }
impl_to_tokens! { u16 }
impl_to_tokens! { u32 }
("non_ascii_idents", "1.0.0", Active),
("thread_local", "1.0.0", Active),
("link_args", "1.0.0", Active),
- ("phase", "1.0.0", Removed),
("plugin_registrar", "1.0.0", Active),
("log_syntax", "1.0.0", Active),
("trace_macros", "1.0.0", Active),
("concat_idents", "1.0.0", Active),
- ("unsafe_destructor", "1.0.0", Active),
("intrinsics", "1.0.0", Active),
("lang_items", "1.0.0", Active),
("rustc_diagnostic_macros", "1.0.0", Active),
("unboxed_closures", "1.0.0", Active),
+ ("reflect", "1.0.0", Active),
("import_shadowing", "1.0.0", Removed),
("advanced_slice_patterns", "1.0.0", Active),
("tuple_indexing", "1.0.0", Accepted),
("start", "1.0.0", Active),
("main", "1.0.0", Active),
+ // Deprecate after snapshot
+ // SNAP a923278
+ ("unsafe_destructor", "1.0.0", Active),
+
// A temporary feature gate used to enable parser extensions needed
// to bootstrap fix for #5723.
("issue_5723_bootstrap", "1.0.0", Accepted),
// A way to temporarily opt out of the new orphan rules. This will *never* be accepted.
("old_orphan_check", "1.0.0", Deprecated),
- // A way to temporarily opt out of the new impl rules. This will *never* be accepted.
- ("old_impl_check", "1.0.0", Deprecated),
-
// OIBIT specific features
("optin_builtin_traits", "1.0.0", Active),
- // int and uint are now deprecated
- ("int_uint", "1.0.0", Active),
-
// macro reexport needs more discussion and stabilization
("macro_reexport", "1.0.0", Active),
// below (it has to be checked before expansion possibly makes
// macros disappear).
("allow_internal_unstable", "1.0.0", Active),
+
+ // #23121. Array patterns have some hazards yet.
+ ("slice_patterns", "1.0.0", Active),
];
// (changing above list without updating src/doc/reference.md makes @cmr sad)
("repr", Normal),
("path", Normal),
("abi", Normal),
- ("unsafe_destructor", Normal),
("automatically_derived", Normal),
("no_mangle", Normal),
("no_link", Normal),
("derive", Normal),
- ("should_fail", Normal),
("should_panic", Normal),
("ignore", Normal),
("no_implicit_prelude", Normal),
("link_args", Normal),
("macro_escape", Normal),
-
+ ("unsafe_destructor", Gated("unsafe_destructor",
+ "`#[unsafe_destructor]` does nothing anymore")),
("staged_api", Gated("staged_api",
"staged_api is for use by rustc only")),
("plugin", Gated("plugin",
// FIXME: #19470 this shouldn't be needed forever
("old_orphan_check", Whitelisted),
- ("old_impl_check", Whitelisted),
- ("rustc_paren_sugar", Whitelisted), // FIXME: #18101 temporary unboxed closure hack
+
+ ("rustc_paren_sugar", Gated("unboxed_closures",
+ "unboxed_closures are still evolving")),
+ ("rustc_reflect_like", Gated("reflect",
+ "defining reflective traits is still evolving")),
// Crate level attributes
("crate_name", CrateLevel),
features: Vec<&'static str>,
span_handler: &'a SpanHandler,
cm: &'a CodeMap,
- do_warnings: bool,
}
impl<'a> Context<'a> {
emit_feature_err(self.span_handler, feature, span, explain);
}
}
-
- fn warn_feature(&self, feature: &str, span: Span, explain: &str) {
- if !self.has_feature(feature) && self.do_warnings {
- emit_feature_warn(self.span_handler, feature, span, explain);
- }
- }
fn has_feature(&self, feature: &str) -> bool {
self.features.iter().any(|&n| n == feature)
}
_ => {}
}
- if attr::contains_name(&i.attrs,
- "unsafe_destructor") {
- self.gate_feature("unsafe_destructor",
- i.span,
- "`#[unsafe_destructor]` allows too \
- many unsafe patterns and may be \
- removed in the future");
- }
-
if attr::contains_name(&i.attrs[..],
"old_orphan_check") {
self.gate_feature(
i.span,
"the new orphan check rules will eventually be strictly enforced");
}
-
- if attr::contains_name(&i.attrs[..],
- "old_impl_check") {
- self.gate_feature("old_impl_check",
- i.span,
- "`#[old_impl_check]` will be removed in the future");
- }
}
_ => {}
visit::walk_foreign_item(self, i)
}
- fn visit_ty(&mut self, t: &ast::Ty) {
- match t.node {
- ast::TyPath(None, ref p) => {
- match &*p.segments {
-
- [ast::PathSegment { identifier, .. }] => {
- let name = token::get_ident(identifier);
- let msg = if name == "int" {
- Some("the `int` type is deprecated; \
- use `isize` or a fixed-sized integer")
- } else if name == "uint" {
- Some("the `uint` type is deprecated; \
- use `usize` or a fixed-sized integer")
- } else {
- None
- };
-
- if let Some(msg) = msg {
- self.context.warn_feature("int_uint", t.span, msg)
- }
- }
- _ => {}
- }
- }
- _ => {}
- }
- visit::walk_ty(self, t);
- }
-
fn visit_expr(&mut self, e: &ast::Expr) {
match e.node {
ast::ExprBox(..) | ast::ExprUnary(ast::UnOp::UnUniq, _) => {
"box expression syntax is experimental; \
you can call `Box::new` instead.");
}
- ast::ExprLit(ref lit) => {
- match lit.node {
- ast::LitInt(_, ty) => {
- let msg = if let ast::SignedIntLit(ast::TyIs(true), _) = ty {
- Some("the `i` and `is` suffixes on integers are deprecated; \
- use `isize` or one of the fixed-sized suffixes")
- } else if let ast::UnsignedIntLit(ast::TyUs(true)) = ty {
- Some("the `u` and `us` suffixes on integers are deprecated; \
- use `usize` or one of the fixed-sized suffixes")
- } else {
- None
- };
- if let Some(msg) = msg {
- self.context.warn_feature("int_uint", e.span, msg);
- }
- }
- _ => {}
- }
- }
_ => {}
}
visit::walk_expr(self, e);
but at the end of a slice (e.g. \
`[0, ..xs, 0]` are experimental")
}
+ ast::PatVec(..) => {
+ self.gate_feature("slice_patterns",
+ pattern.span,
+ "slice pattern syntax is experimental");
+ }
ast::PatBox(..) => {
self.gate_feature("box_patterns",
pattern.span,
}
}
-fn check_crate_inner<F>(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate,
- do_warnings: bool,
+fn check_crate_inner<F>(cm: &CodeMap, span_handler: &SpanHandler,
+ krate: &ast::Crate,
check: F)
-> Features
where F: FnOnce(&mut Context, &ast::Crate)
let mut cx = Context {
features: Vec::new(),
span_handler: span_handler,
- do_warnings: do_warnings,
cm: cm,
};
pub fn check_crate_macros(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate)
-> Features {
- check_crate_inner(cm, span_handler, krate, true,
+ check_crate_inner(cm, span_handler, krate,
|ctx, krate| visit::walk_crate(&mut MacroVisitor { context: ctx }, krate))
}
-pub fn check_crate(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate,
- do_warnings: bool) -> Features
+pub fn check_crate(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate)
+ -> Features
{
- check_crate_inner(cm, span_handler, krate, do_warnings,
+ check_crate_inner(cm, span_handler, krate,
|ctx, krate| visit::walk_crate(&mut PostExpansionVisitor { context: ctx },
krate))
}
for p in &mut self {
unsafe {
// FIXME(#5016) this shouldn't need to zero to be safe.
- ptr::write(p, f(ptr::read_and_zero(p)));
+ ptr::write(p, f(ptr::read_and_drop(p)));
}
}
self
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(libc)]
#![feature(old_path)]
#![feature(quote, unsafe_destructor)]
#![feature(str_char)]
#![feature(convert)]
#![feature(into_cow)]
+#![feature(slice_patterns)]
extern crate arena;
extern crate fmt_macros;
#[macro_use] extern crate log;
#[macro_use] #[no_link] extern crate rustc_bitflags;
-extern crate "serialize" as rustc_serialize; // used by deriving
+extern crate serialize as rustc_serialize; // used by deriving
pub mod util {
pub mod interner;
use diagnostic::SpanHandler;
use ext::tt::transcribe::tt_next_token;
use parse::token;
-use parse::token::{str_to_ident};
+use parse::token::str_to_ident;
use std::borrow::{IntoCow, Cow};
use std::char;
use std::fmt;
use std::mem::replace;
-use std::num;
use std::rc::Rc;
pub use ext::tt::transcribe::{TtReader, new_tt_reader, new_tt_reader_with_doc_flag};
// find the integer representing the name
self.scan_digits(base);
- let encoded_name : u32 = self.with_str_from(start_bpos, |s| {
- num::from_str_radix(s, 10).unwrap_or_else(|_| {
+ let encoded_name: u32 = self.with_str_from(start_bpos, |s| {
+ u32::from_str_radix(s, 10).unwrap_or_else(|_| {
panic!("expected digits representing a name, got {:?}, {}, range [{:?},{:?}]",
s, whence, start_bpos, self.last_pos);
})
let start_bpos = self.last_pos;
self.scan_digits(base);
let encoded_ctxt : ast::SyntaxContext = self.with_str_from(start_bpos, |s| {
- num::from_str_radix(s, 10).unwrap_or_else(|_| {
+ u32::from_str_radix(s, 10).unwrap_or_else(|_| {
panic!("expected digits representing a ctxt, got {:?}, {}", s, whence);
})
});
let start_bpos = self.last_pos;
let mut accum_int = 0;
+ let mut valid = true;
for _ in 0..n_digits {
if self.is_eof() {
let last_bpos = self.last_pos;
if self.curr_is(delim) {
let last_bpos = self.last_pos;
self.err_span_(start_bpos, last_bpos, "numeric character escape is too short");
+ valid = false;
break;
}
let c = self.curr.unwrap_or('\x00');
accum_int += c.to_digit(16).unwrap_or_else(|| {
self.err_span_char(self.last_pos, self.pos,
"illegal character in numeric character escape", c);
+
+ valid = false;
0
});
self.bump();
self.last_pos,
"this form of character escape may only be used \
with characters in the range [\\x00-\\x7f]");
+ valid = false;
}
match char::from_u32(accum_int) {
- Some(_) => true,
+ Some(_) => valid,
None => {
let last_bpos = self.last_pos;
self.err_span_(start_bpos, last_bpos, "illegal numeric character escape");
'n' | 'r' | 't' | '\\' | '\'' | '"' | '0' => true,
'x' => self.scan_byte_escape(delim, !ascii_only),
'u' if self.curr_is('{') => {
- self.scan_unicode_escape(delim)
+ let valid = self.scan_unicode_escape(delim);
+ if valid && ascii_only {
+ self.err_span_(
+ escaped_pos,
+ self.last_pos,
+ "unicode escape sequences cannot be used as a byte or in \
+ a byte string"
+ );
+ false
+ } else {
+ valid
+ }
}
'\n' if delim == '"' => {
self.consume_whitespace();
let start_bpos = self.last_pos;
let mut count = 0;
let mut accum_int = 0;
+ let mut valid = true;
while !self.curr_is('}') && count <= 6 {
let c = match self.curr {
self.fatal_span_(self.last_pos, self.pos,
"unterminated unicode escape (needed a `}`)");
} else {
- self.fatal_span_char(self.last_pos, self.pos,
+ self.err_span_char(self.last_pos, self.pos,
"illegal character in unicode escape", c);
}
+ valid = false;
+ 0
});
self.bump();
count += 1;
}
if count > 6 {
- self.fatal_span_(start_bpos, self.last_pos,
+ self.err_span_(start_bpos, self.last_pos,
"overlong unicode escape (can have at most 6 hex digits)");
+ valid = false;
}
self.bump(); // past the ending }
- let mut valid = count >= 1 && count <= 6;
- if char::from_u32(accum_int).is_none() {
- valid = false;
+ if valid && (char::from_u32(accum_int).is_none() || count == 0) {
+ self.err_span_(start_bpos, self.last_pos, "illegal unicode character escape");
+ valid= false;
}
- if !valid {
- self.fatal_span_(start_bpos, self.last_pos, "illegal unicode character escape");
- }
+
valid
}
"unterminated byte constant".to_string());
}
- let id = if valid { self.name_from(start) } else { token::intern("??") };
+ let id = if valid { self.name_from(start) } else { token::intern("?") };
self.bump(); // advance curr past token
return token::Byte(id);
}
use std::fs::File;
use std::io::Read;
use std::iter;
+#[allow(deprecated)] // Int
use std::num::Int;
use std::path::{Path, PathBuf};
use std::rc::Rc;
/// well. Can take any slice prefixed by a character escape. Returns the
/// character and the number of characters consumed.
pub fn char_lit(lit: &str) -> (char, isize) {
- use std::{num, char};
+ use std::char;
let mut chars = lit.chars();
let c = match (chars.next(), chars.next()) {
let msg2 = &msg[..];
fn esc(len: usize, lit: &str) -> Option<(char, isize)> {
- num::from_str_radix(&lit[2..len], 16).ok()
+ u32::from_str_radix(&lit[2..len], 16).ok()
.and_then(char::from_u32)
.map(|x| (x, len as isize))
}
if lit.as_bytes()[2] == b'{' {
let idx = lit.find('}').expect(msg2);
let subslice = &lit[3..idx];
- num::from_str_radix(subslice, 16).ok()
+ u32::from_str_radix(subslice, 16).ok()
.and_then(char::from_u32)
.map(|x| (x, subslice.chars().count() as isize + 4))
} else {
b'\'' => b'\'',
b'0' => b'\0',
_ => {
- match ::std::num::from_str_radix::<u64>(&lit[2..4], 16).ok() {
+ match u64::from_str_radix(&lit[2..4], 16).ok() {
Some(c) =>
if c > 0xFF {
panic!(err(2))
if let Some(suf) = suffix {
if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")}
ty = match suf {
- "isize" => ast::SignedIntLit(ast::TyIs(false), ast::Plus),
+ "isize" => ast::SignedIntLit(ast::TyIs, ast::Plus),
"i8" => ast::SignedIntLit(ast::TyI8, ast::Plus),
"i16" => ast::SignedIntLit(ast::TyI16, ast::Plus),
"i32" => ast::SignedIntLit(ast::TyI32, ast::Plus),
"i64" => ast::SignedIntLit(ast::TyI64, ast::Plus),
- "usize" => ast::UnsignedIntLit(ast::TyUs(false)),
+ "usize" => ast::UnsignedIntLit(ast::TyUs),
"u8" => ast::UnsignedIntLit(ast::TyU8),
"u16" => ast::UnsignedIntLit(ast::TyU16),
"u32" => ast::UnsignedIntLit(ast::TyU32),
"u64" => ast::UnsignedIntLit(ast::TyU64),
- "i" | "is" => ast::SignedIntLit(ast::TyIs(true), ast::Plus),
- "u" | "us" => ast::UnsignedIntLit(ast::TyUs(true)),
+ "is" => ast::SignedIntLit(ast::TyIs, ast::Plus),
+ "us" => ast::UnsignedIntLit(ast::TyUs),
_ => {
// i<digits> and u<digits> look like widths, so lets
// give an error message along those lines
debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \
string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix);
- let res: u64 = match ::std::num::from_str_radix(s, base).ok() {
+ let res = match u64::from_str_radix(s, base).ok() {
Some(r) => r,
None => { sd.span_err(sp, "int literal is too large"); 0 }
};
#[derive(Copy, PartialEq, Eq, Hash)]
pub enum ObsoleteSyntax {
ClosureKind,
- EmptyIndex,
ExternCrateString,
}
"rely on inference instead",
true,
),
- ObsoleteSyntax::EmptyIndex => (
- "[]",
- "write `[..]` instead",
- false, // warning for now
- ),
ObsoleteSyntax::ExternCrateString => (
"\"crate-name\"",
"use an identifier not in quotes instead",
pub use self::PathParsingMode::*;
use abi;
-use ast::{BareFnTy};
+use ast::BareFnTy;
use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
use ast::{Public, Unsafety};
use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue};
// expr[...]
// Could be either an index expression or a slicing expression.
token::OpenDelim(token::Bracket) => {
- let bracket_pos = self.span.lo;
self.bump();
- if self.eat(&token::CloseDelim(token::Bracket)) {
- // No expression, expand to a RangeFull
- // FIXME(#20516) It would be better to use a lang item or
- // something for RangeFull.
- hi = self.last_span.hi;
-
- let idents = vec![token::str_to_ident("std"),
- token::str_to_ident("ops"),
- token::str_to_ident("RangeFull")];
- let segments = idents.into_iter().map(|ident| {
- ast::PathSegment {
- identifier: ident,
- parameters: ast::PathParameters::none(),
- }
- }).collect();
- let span = mk_sp(lo, hi);
- let path = ast::Path {
- span: span,
- global: true,
- segments: segments,
- };
-
- let range = ExprStruct(path, vec![], None);
- let ix = self.mk_expr(bracket_pos, hi, range);
- let index = self.mk_index(e, ix);
- e = self.mk_expr(lo, hi, index);
-
- let obsolete_span = mk_sp(bracket_pos, hi);
- self.obsolete(obsolete_span, ObsoleteSyntax::EmptyIndex);
- } else {
- let ix = self.parse_expr();
- hi = self.span.hi;
- self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket));
- let index = self.mk_index(e, ix);
- e = self.mk_expr(lo, hi, index)
- }
-
+ let ix = self.parse_expr();
+ hi = self.span.hi;
+ self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket));
+ let index = self.mk_index(e, ix);
+ e = self.mk_expr(lo, hi, index)
}
_ => return e
}
///
/// # Examples
///
- /// extern crate url;
- /// extern crate foo = "bar"; //deprecated
- /// extern crate "bar" as foo;
+ /// extern crate foo;
+ /// extern crate bar as foo;
fn parse_item_extern_crate(&mut self,
- lo: BytePos,
- visibility: Visibility,
+ lo: BytePos,
+ visibility: Visibility,
+ attrs: Vec<Attribute>)
-> P<Item> {
- let (maybe_path, ident) = match self.token {
- token::Ident(..) => {
- let crate_name = self.parse_ident();
- if self.eat_keyword(keywords::As) {
- (Some(crate_name.name), self.parse_ident())
- } else {
- (None, crate_name)
- }
- },
- token::Literal(token::Str_(..), suf) |
- token::Literal(token::StrRaw(..), suf) => {
- let sp = self.span;
- self.expect_no_suffix(sp, "extern crate name", suf);
- // forgo the internal suffix check of `parse_str` to
- // avoid repeats (this unwrap will always succeed due
- // to the restriction of the `match`)
- let (s, _, _) = self.parse_optional_str().unwrap();
- self.expect_keyword(keywords::As);
- let the_ident = self.parse_ident();
- self.obsolete(sp, ObsoleteSyntax::ExternCrateString);
- let s = token::intern(&s);
- (Some(s), the_ident)
- },
- _ => {
- let span = self.span;
- let token_str = self.this_token_to_string();
- self.span_fatal(span,
- &format!("expected extern crate name but \
- found `{}`",
- token_str));
- }
+ let crate_name = self.parse_ident();
+ let (maybe_path, ident) = if self.eat_keyword(keywords::As) {
+ (Some(crate_name.name), self.parse_ident())
+ } else {
+ (None, crate_name)
};
self.expect(&token::Semi);
{
unsafe {
let p = &mut *self.ptr;
- // FIXME(#5016) this shouldn't need to zero to be safe.
- ptr::write(p, f(ptr::read_and_zero(p)));
+ // FIXME(#5016) this shouldn't need to drop-fill to be safe.
+ ptr::write(p, f(ptr::read_and_drop(p)));
}
self
}
impl fold::Folder for StandardLibraryInjector {
fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
- // The name to use in `extern crate "name" as std;`
+ // The name to use in `extern crate name as std;`
let actual_crate_name = match self.alt_std_name {
Some(ref s) => token::intern(&s),
None => token::intern("std"),
path: self.cx.path.clone(),
bench: is_bench_fn(&self.cx, &*i),
ignore: is_ignored(&*i),
- should_panic: should_panic(&*i, self.cx.span_diagnostic)
+ should_panic: should_panic(&*i)
};
self.cx.testfns.push(test);
self.tests.push(i.ident);
i.attrs.iter().any(|attr| attr.check_name("ignore"))
}
-fn should_panic(i: &ast::Item, diag: &diagnostic::SpanHandler) -> ShouldPanic {
- match i.attrs.iter().find(|attr| {
- if attr.check_name("should_panic") { return true; }
- if attr.check_name("should_fail") {
- diag.span_warn(attr.span, "`#[should_fail]` is deprecated. Use `#[should_panic]` \
- instead");
- return true;
- }
- false
- }) {
+fn should_panic(i: &ast::Item) -> ShouldPanic {
+ match i.attrs.iter().find(|attr| attr.check_name("should_panic")) {
Some(attr) => {
let msg = attr.meta_item_list()
.and_then(|list| list.iter().find(|mi| mi.check_name("expected")))
// except according to those terms.
use ast;
-use parse::{new_parse_sess};
+use parse::new_parse_sess;
use parse::{ParseSess,string_to_filemap,filemap_to_tts};
-use parse::{new_parser_from_source_str};
+use parse::new_parser_from_source_str;
use parse::parser::Parser;
use parse::token;
use ptr::P;
#![feature(box_syntax)]
#![feature(collections)]
-#![feature(int_uint)]
#![feature(rustc_private)]
#![feature(staged_api)]
#![feature(std_misc)]
.get("setaf")
.unwrap()
,
- &[Number(color as int)], &mut Variables::new());
+ &[Number(color as isize)], &mut Variables::new());
if s.is_ok() {
try!(self.out.write_all(&s.unwrap()));
return Ok(true)
.get("setab")
.unwrap()
,
- &[Number(color as int)], &mut Variables::new());
+ &[Number(color as isize)], &mut Variables::new());
if s.is_ok() {
try!(self.out.write_all(&s.unwrap()));
return Ok(true)
PushParam,
CharConstant,
CharClose,
- IntConstant(int),
+ IntConstant(isize),
FormatPattern(Flags, FormatState),
- SeekIfElse(int),
- SeekIfElsePercent(int),
- SeekIfEnd(int),
- SeekIfEndPercent(int)
+ SeekIfElse(isize),
+ SeekIfElsePercent(isize),
+ SeekIfEnd(isize),
+ SeekIfEndPercent(isize)
}
#[derive(Copy, PartialEq)]
#[derive(Clone)]
pub enum Param {
Words(String),
- Number(int)
+ Number(isize)
}
/// Container for static and dynamic variable arrays
'{' => state = IntConstant(0),
'l' => if stack.len() > 0 {
match stack.pop().unwrap() {
- Words(s) => stack.push(Number(s.len() as int)),
+ Words(s) => stack.push(Number(s.len() as isize)),
_ => return Err("a non-str was used with %l".to_string())
}
} else { return Err("stack is empty".to_string()) },
' ' => flags.space = true,
'.' => fstate = FormatStatePrecision,
'0'...'9' => {
- flags.width = cur as uint - '0' as uint;
+ flags.width = cur as usize - '0' as usize;
fstate = FormatStateWidth;
}
_ => unreachable!()
if cur >= 'A' && cur <= 'Z' {
if stack.len() > 0 {
let idx = (cur as u8) - b'A';
- vars.sta[idx as uint] = stack.pop().unwrap();
+ vars.sta[idx as usize] = stack.pop().unwrap();
} else { return Err("stack is empty".to_string()) }
} else if cur >= 'a' && cur <= 'z' {
if stack.len() > 0 {
let idx = (cur as u8) - b'a';
- vars.dyn[idx as uint] = stack.pop().unwrap();
+ vars.dyn[idx as usize] = stack.pop().unwrap();
} else { return Err("stack is empty".to_string()) }
} else {
return Err("bad variable name in %P".to_string());
GetVar => {
if cur >= 'A' && cur <= 'Z' {
let idx = (cur as u8) - b'A';
- stack.push(vars.sta[idx as uint].clone());
+ stack.push(vars.sta[idx as usize].clone());
} else if cur >= 'a' && cur <= 'z' {
let idx = (cur as u8) - b'a';
- stack.push(vars.dyn[idx as uint].clone());
+ stack.push(vars.dyn[idx as usize].clone());
} else {
return Err("bad variable name in %g".to_string());
}
},
CharConstant => {
- stack.push(Number(c as int));
+ stack.push(Number(c as isize));
state = CharClose;
},
CharClose => {
state = Nothing;
}
'0'...'9' => {
- state = IntConstant(i*10 + (cur as int - '0' as int));
+ state = IntConstant(i*10 + (cur as isize - '0' as isize));
old_state = Nothing;
}
- _ => return Err("bad int constant".to_string())
+ _ => return Err("bad isize constant".to_string())
}
}
FormatPattern(ref mut flags, ref mut fstate) => {
flags.space = true;
}
(FormatStateFlags,'0'...'9') => {
- flags.width = cur as uint - '0' as uint;
+ flags.width = cur as usize - '0' as usize;
*fstate = FormatStateWidth;
}
(FormatStateFlags,'.') => {
}
(FormatStateWidth,'0'...'9') => {
let old = flags.width;
- flags.width = flags.width * 10 + (cur as uint - '0' as uint);
+ flags.width = flags.width * 10 + (cur as usize - '0' as usize);
if flags.width < old { return Err("format width overflow".to_string()) }
}
(FormatStateWidth,'.') => {
}
(FormatStatePrecision,'0'...'9') => {
let old = flags.precision;
- flags.precision = flags.precision * 10 + (cur as uint - '0' as uint);
+ flags.precision = flags.precision * 10 + (cur as usize - '0' as usize);
if flags.precision < old {
return Err("format precision overflow".to_string())
}
#[derive(Copy, PartialEq)]
struct Flags {
- width: uint,
- precision: uint,
+ width: usize,
+ precision: usize,
alternate: bool,
left: bool,
sign: bool,
0x011A_usize, magic as usize));
}
- let names_bytes = try!(read_le_u16(file)) as int;
- let bools_bytes = try!(read_le_u16(file)) as int;
- let numbers_count = try!(read_le_u16(file)) as int;
- let string_offsets_count = try!(read_le_u16(file)) as int;
- let string_table_bytes = try!(read_le_u16(file)) as int;
+ let names_bytes = try!(read_le_u16(file)) as isize;
+ let bools_bytes = try!(read_le_u16(file)) as isize;
+ let numbers_count = try!(read_le_u16(file)) as isize;
+ let string_offsets_count = try!(read_le_u16(file)) as isize;
+ let string_table_bytes = try!(read_le_u16(file)) as isize;
assert!(names_bytes > 0);
- if (bools_bytes as uint) > boolnames.len() {
+ if (bools_bytes as usize) > boolnames.len() {
return Err("incompatible file: more booleans than \
expected".to_string());
}
- if (numbers_count as uint) > numnames.len() {
+ if (numbers_count as usize) > numnames.len() {
return Err("incompatible file: more numbers than \
expected".to_string());
}
- if (string_offsets_count as uint) > stringnames.len() {
+ if (string_offsets_count as usize) > stringnames.len() {
return Err("incompatible file: more string offsets than \
expected".to_string());
}
// don't read NUL
- let bytes = try!(read_exact(file, names_bytes as uint - 1));
+ let bytes = try!(read_exact(file, names_bytes as usize - 1));
let names_str = match String::from_utf8(bytes) {
Ok(s) => s,
Err(_) => return Err("input not utf-8".to_string()),
for i in 0..bools_bytes {
let b = try!(read_byte(file));
if b == 1 {
- bools_map.insert(bnames[i as uint].to_string(), true);
+ bools_map.insert(bnames[i as usize].to_string(), true);
}
}
}
for i in 0..numbers_count {
let n = try!(read_le_u16(file));
if n != 0xFFFF {
- numbers_map.insert(nnames[i as uint].to_string(), n);
+ numbers_map.insert(nnames[i as usize].to_string(), n);
}
}
}
let string_table = try!(read_exact(file, string_table_bytes as usize));
- if string_table.len() != string_table_bytes as uint {
+ if string_table.len() != string_table_bytes as usize {
return Err("error: hit EOF before end of string \
table".to_string());
}
// Find the offset of the NUL we want to go to
- let nulpos = string_table[offset as uint .. string_table_bytes as uint]
+ let nulpos = string_table[offset as usize .. string_table_bytes as usize]
.iter().position(|&b| b == 0);
match nulpos {
Some(len) => {
string_map.insert(name.to_string(),
- string_table[offset as uint ..
- (offset as uint + len)].to_vec())
+ string_table[offset as usize ..
+ (offset as usize + len)].to_vec())
},
None => {
return Err("invalid file: missing NUL in \
return Some(box newp);
}
// on some installations the dir is named after the hex of the char (e.g. OS X)
- let f = format!("{:x}", first_char as uint);
+ let f = format!("{:x}", first_char as usize);
let newp = p.join(&f).join(term);
if newp.exists() {
return Some(box newp);
#![feature(box_syntax)]
#![feature(collections)]
#![feature(core)]
-#![feature(int_uint)]
#![feature(rustc_private)]
#![feature(staged_api)]
#![feature(std_misc)]
extern crate getopts;
extern crate serialize;
-extern crate "serialize" as rustc_serialize;
+extern crate serialize as rustc_serialize;
extern crate term;
extern crate libc;
use std::io;
use std::iter::repeat;
use std::num::{Float, Int};
-use std::path::{PathBuf};
+use std::path::PathBuf;
use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex};
use std::thread;
}
impl TestDesc {
- fn padded_name(&self, column_count: uint, align: NamePadding) -> String {
+ fn padded_name(&self, column_count: usize, align: NamePadding) -> String {
let mut name = String::from_str(self.name.as_slice());
let fill = column_count.saturating_sub(name.len());
let mut pad = repeat(" ").take(fill).collect::<String>();
only those tests that match are run.
By default, all tests are run in parallel. This can be altered with the
-RUST_TEST_THRADS environment variable when running tests (set it to 1).
+RUST_TEST_THREADS environment variable when running tests (set it to 1).
All tests have their standard output and standard error captured by default.
This can be overridden with the --nocapture flag or the RUST_TEST_NOCAPTURE=1
#[derive(Clone, PartialEq)]
pub struct BenchSamples {
ns_iter_summ: stats::Summary<f64>,
- mb_s: uint,
+ mb_s: usize,
}
#[derive(Clone, PartialEq)]
log_out: Option<File>,
out: OutputLocation<T>,
use_color: bool,
- total: uint,
- passed: uint,
- failed: uint,
- ignored: uint,
- measured: uint,
+ total: usize,
+ passed: usize,
+ failed: usize,
+ ignored: usize,
+ measured: usize,
metrics: MetricMap,
failures: Vec<(TestDesc, Vec<u8> )> ,
- max_name_len: uint, // number of columns to fill when aligning names
+ max_name_len: usize, // number of columns to fill when aligning names
}
impl<T: Write> ConsoleTestState<T> {
}
}
- pub fn write_run_start(&mut self, len: uint) -> io::Result<()> {
+ pub fn write_run_start(&mut self, len: usize) -> io::Result<()> {
self.total = len;
let noun = if len != 1 { "tests" } else { "test" };
self.write_plain(&format!("\nrunning {} {}\n", len, noun))
pub fn fmt_bench_samples(bs: &BenchSamples) -> String {
if bs.mb_s != 0 {
format!("{:>9} ns/iter (+/- {}) = {} MB/s",
- bs.ns_iter_summ.median as uint,
- (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as uint,
+ bs.ns_iter_summ.median as usize,
+ (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize,
bs.mb_s)
} else {
format!("{:>9} ns/iter (+/- {})",
- bs.ns_iter_summ.median as uint,
- (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as uint)
+ bs.ns_iter_summ.median as usize,
+ (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize)
}
}
}
let mut st = try!(ConsoleTestState::new(opts, None::<io::Stdout>));
- fn len_if_padded(t: &TestDescAndFn) -> uint {
+ fn len_if_padded(t: &TestDescAndFn) -> usize {
match t.testfn.padding() {
PadNone => 0,
PadOnLeft | PadOnRight => t.desc.name.as_slice().len(),
}
#[allow(deprecated)]
-fn get_concurrency() -> uint {
+fn get_concurrency() -> usize {
match env::var("RUST_TEST_THREADS") {
Ok(s) => {
- let opt_n: Option<uint> = s.parse().ok();
+ let opt_n: Option<usize> = s.parse().ok();
match opt_n {
Some(n) if n > 0 => n,
_ => panic!("RUST_TEST_THREADS is `{}`, should be a positive integer.", s)
BenchSamples {
ns_iter_summ: ns_iter_summ,
- mb_s: mb_s as uint
+ mb_s: mb_s as usize
}
}
}
let names =
vec!("sha1::test".to_string(),
- "int::test_to_str".to_string(),
- "int::test_pow".to_string(),
+ "isize::test_to_str".to_string(),
+ "isize::test_pow".to_string(),
"test::do_not_run_ignored_tests".to_string(),
"test::ignored_tests_result_in_ignored".to_string(),
"test::first_free_arg_should_be_a_filter".to_string(),
let filtered = filter_tests(&opts, tests);
let expected =
- vec!("int::test_pow".to_string(),
- "int::test_to_str".to_string(),
+ vec!("isize::test_pow".to_string(),
+ "isize::test_to_str".to_string(),
"sha1::test".to_string(),
"test::do_not_run_ignored_tests".to_string(),
"test::filter_for_ignored_option".to_string(),
// except according to those terms.
#![allow(missing_docs)]
+#![allow(deprecated)] // Float
use std::cmp::Ordering::{self, Less, Greater, Equal};
use std::mem;
pub use tables::normalization::canonical_combining_class;
pub use tables::UNICODE_VERSION;
-#[cfg(stage0)]
-/// Functionality for manipulating `char`.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait CharExt {
- /// Checks if a `char` parses as a numeric digit in the given radix.
- ///
- /// Compared to `is_numeric()`, this function only recognizes the characters
- /// `0-9`, `a-z` and `A-Z`.
- ///
- /// # Return value
- ///
- /// Returns `true` if `c` is a valid digit under `radix`, and `false`
- /// otherwise.
- ///
- /// # Panics
- ///
- /// Panics if given a radix > 36.
- ///
- /// # Examples
- ///
- /// ```
- /// let c = '1';
- ///
- /// assert!(c.is_digit(10));
- ///
- /// assert!('f'.is_digit(16));
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_digit(self, radix: u32) -> bool;
-
- /// Converts a character to the corresponding digit.
- ///
- /// # Return value
- ///
- /// If `c` is between '0' and '9', the corresponding value between 0 and
- /// 9. If `c` is 'a' or 'A', 10. If `c` is 'b' or 'B', 11, etc. Returns
- /// none if the character does not refer to a digit in the given radix.
- ///
- /// # Panics
- ///
- /// Panics if given a radix outside the range [0..36].
- ///
- /// # Examples
- ///
- /// ```
- /// let c = '1';
- ///
- /// assert_eq!(c.to_digit(10), Some(1));
- ///
- /// assert_eq!('f'.to_digit(16), Some(15));
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn to_digit(self, radix: u32) -> Option<u32>;
-
- /// Returns an iterator that yields the hexadecimal Unicode escape of a
- /// character, as `char`s.
- ///
- /// All characters are escaped with Rust syntax of the form `\\u{NNNN}`
- /// where `NNNN` is the shortest hexadecimal representation of the code
- /// point.
- ///
- /// # Examples
- ///
- /// ```
- /// for i in '❤'.escape_unicode() {
- /// println!("{}", i);
- /// }
- /// ```
- ///
- /// This prints:
- ///
- /// ```text
- /// \
- /// u
- /// {
- /// 2
- /// 7
- /// 6
- /// 4
- /// }
- /// ```
- ///
- /// Collecting into a `String`:
- ///
- /// ```
- /// let heart: String = '❤'.escape_unicode().collect();
- ///
- /// assert_eq!(heart, r"\u{2764}");
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn escape_unicode(self) -> EscapeUnicode;
-
- /// Returns an iterator that yields the 'default' ASCII and
- /// C++11-like literal escape of a character, as `char`s.
- ///
- /// The default is chosen with a bias toward producing literals that are
- /// legal in a variety of languages, including C++11 and similar C-family
- /// languages. The exact rules are:
- ///
- /// * Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
- /// * Single-quote, double-quote and backslash chars are backslash-
- /// escaped.
- /// * Any other chars in the range [0x20,0x7e] are not escaped.
- /// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
- ///
- /// # Examples
- ///
- /// ```
- /// for i in '"'.escape_default() {
- /// println!("{}", i);
- /// }
- /// ```
- ///
- /// This prints:
- ///
- /// ```text
- /// \
- /// "
- /// ```
- ///
- /// Collecting into a `String`:
- ///
- /// ```
- /// let quote: String = '"'.escape_default().collect();
- ///
- /// assert_eq!(quote, "\\\"");
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn escape_default(self) -> EscapeDefault;
-
- /// Returns the number of bytes this character would need if encoded in
- /// UTF-8.
- ///
- /// # Examples
- ///
- /// ```
- /// let n = 'ß'.len_utf8();
- ///
- /// assert_eq!(n, 2);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn len_utf8(self) -> usize;
-
- /// Returns the number of 16-bit code units this character would need if
- /// encoded in UTF-16.
- ///
- /// # Examples
- ///
- /// ```
- /// let n = 'ß'.len_utf16();
- ///
- /// assert_eq!(n, 1);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn len_utf16(self) -> usize;
-
- /// Encodes this character as UTF-8 into the provided byte buffer, and then
- /// returns the number of bytes written.
- ///
- /// If the buffer is not large enough, nothing will be written into it and a
- /// `None` will be returned. A buffer of length four is large enough to
- /// encode any `char`.
- ///
- /// # Examples
- ///
- /// In both of these examples, 'ß' takes two bytes to encode.
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 2];
- ///
- /// let result = 'ß'.encode_utf8(&mut b);
- ///
- /// assert_eq!(result, Some(2));
- /// ```
- ///
- /// A buffer that's too small:
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 1];
- ///
- /// let result = 'ß'.encode_utf8(&mut b);
- ///
- /// assert_eq!(result, None);
- /// ```
- #[unstable(feature = "unicode",
- reason = "pending decision about Iterator/Writer/Reader")]
- fn encode_utf8(self, dst: &mut [u8]) -> Option<usize>;
-
- /// Encodes this character as UTF-16 into the provided `u16` buffer, and
- /// then returns the number of `u16`s written.
- ///
- /// If the buffer is not large enough, nothing will be written into it and a
- /// `None` will be returned. A buffer of length 2 is large enough to encode
- /// any `char`.
- ///
- /// # Examples
- ///
- /// In both of these examples, 'ß' takes one `u16` to encode.
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 1];
- ///
- /// let result = 'ß'.encode_utf16(&mut b);
- ///
- /// assert_eq!(result, Some(1));
- /// ```
- ///
- /// A buffer that's too small:
- ///
- /// ```
- /// # #![feature(unicode)]
- /// let mut b = [0; 0];
- ///
- /// let result = 'ß'.encode_utf8(&mut b);
- ///
- /// assert_eq!(result, None);
- /// ```
- #[unstable(feature = "unicode",
- reason = "pending decision about Iterator/Writer/Reader")]
- fn encode_utf16(self, dst: &mut [u16]) -> Option<usize>;
-
- /// Returns whether the specified character is considered a Unicode
- /// alphabetic code point.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_alphabetic(self) -> bool;
-
- /// Returns whether the specified character satisfies the 'XID_Start'
- /// Unicode property.
- ///
- /// 'XID_Start' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to ID_Start but modified for closure under NFKx.
- #[unstable(feature = "unicode",
- reason = "mainly needed for compiler internals")]
- fn is_xid_start(self) -> bool;
-
- /// Returns whether the specified `char` satisfies the 'XID_Continue'
- /// Unicode property.
- ///
- /// 'XID_Continue' is a Unicode Derived Property specified in
- /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
- /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
- #[unstable(feature = "unicode",
- reason = "mainly needed for compiler internals")]
- fn is_xid_continue(self) -> bool;
-
- /// Indicates whether a character is in lowercase.
- ///
- /// This is defined according to the terms of the Unicode Derived Core
- /// Property `Lowercase`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_lowercase(self) -> bool;
-
- /// Indicates whether a character is in uppercase.
- ///
- /// This is defined according to the terms of the Unicode Derived Core
- /// Property `Uppercase`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_uppercase(self) -> bool;
-
- /// Indicates whether a character is whitespace.
- ///
- /// Whitespace is defined in terms of the Unicode Property `White_Space`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_whitespace(self) -> bool;
-
- /// Indicates whether a character is alphanumeric.
- ///
- /// Alphanumericness is defined in terms of the Unicode General Categories
- /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_alphanumeric(self) -> bool;
-
- /// Indicates whether a character is a control code point.
- ///
- /// Control code points are defined in terms of the Unicode General
- /// Category `Cc`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_control(self) -> bool;
-
- /// Indicates whether the character is numeric (Nd, Nl, or No).
- #[stable(feature = "rust1", since = "1.0.0")]
- fn is_numeric(self) -> bool;
-
- /// Converts a character to its lowercase equivalent.
- ///
- /// The case-folding performed is the common or simple mapping. See
- /// `to_uppercase()` for references and more information.
- ///
- /// # Return value
- ///
- /// Returns an iterator which yields the characters corresponding to the
- /// lowercase equivalent of the character. If no conversion is possible then
- /// the input character is returned.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn to_lowercase(self) -> ToLowercase;
-
- /// Converts a character to its uppercase equivalent.
- ///
- /// The case-folding performed is the common or simple mapping: it maps
- /// one Unicode codepoint to its uppercase equivalent according to the
- /// Unicode database [1]. The additional [`SpecialCasing.txt`] is not yet
- /// considered here, but the iterator returned will soon support this form
- /// of case folding.
- ///
- /// A full reference can be found here [2].
- ///
- /// # Return value
- ///
- /// Returns an iterator which yields the characters corresponding to the
- /// uppercase equivalent of the character. If no conversion is possible then
- /// the input character is returned.
- ///
- /// [1]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
- ///
- /// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
- ///
- /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
- #[stable(feature = "rust1", since = "1.0.0")]
- fn to_uppercase(self) -> ToUppercase;
-
- /// Returns this character's displayed width in columns, or `None` if it is a
- /// control character other than `'\x00'`.
- ///
- /// `is_cjk` determines behavior for characters in the Ambiguous category:
- /// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1.
- /// In CJK contexts, `is_cjk` should be `true`, else it should be `false`.
- /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
- /// recommends that these characters be treated as 1 column (i.e.,
- /// `is_cjk` = `false`) if the context cannot be reliably determined.
- #[unstable(feature = "unicode",
- reason = "needs expert opinion. is_cjk flag stands out as ugly")]
- fn width(self, is_cjk: bool) -> Option<usize>;
-}
-
-#[cfg(stage0)]
-#[stable(feature = "rust1", since = "1.0.0")]
-impl CharExt for char {
- #[inline]
- fn is_digit(self, radix: u32) -> bool { C::is_digit(self, radix) }
- fn to_digit(self, radix: u32) -> Option<u32> { C::to_digit(self, radix) }
- fn escape_unicode(self) -> EscapeUnicode { C::escape_unicode(self) }
- fn escape_default(self) -> EscapeDefault { C::escape_default(self) }
- fn len_utf8(self) -> usize { C::len_utf8(self) }
- fn len_utf16(self) -> usize { C::len_utf16(self) }
- fn encode_utf8(self, dst: &mut [u8]) -> Option<usize> { C::encode_utf8(self, dst) }
- fn encode_utf16(self, dst: &mut [u16]) -> Option<usize> { C::encode_utf16(self, dst) }
-
- #[inline]
- fn is_alphabetic(self) -> bool {
- match self {
- 'a' ... 'z' | 'A' ... 'Z' => true,
- c if c > '\x7f' => derived_property::Alphabetic(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_xid_start(self) -> bool { derived_property::XID_Start(self) }
-
- #[inline]
- fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) }
-
- #[inline]
- fn is_lowercase(self) -> bool {
- match self {
- 'a' ... 'z' => true,
- c if c > '\x7f' => derived_property::Lowercase(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_uppercase(self) -> bool {
- match self {
- 'A' ... 'Z' => true,
- c if c > '\x7f' => derived_property::Uppercase(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_whitespace(self) -> bool {
- match self {
- ' ' | '\x09' ... '\x0d' => true,
- c if c > '\x7f' => property::White_Space(c),
- _ => false
- }
- }
-
- #[inline]
- fn is_alphanumeric(self) -> bool {
- self.is_alphabetic() || self.is_numeric()
- }
-
- #[inline]
- fn is_control(self) -> bool { general_category::Cc(self) }
-
- #[inline]
- fn is_numeric(self) -> bool {
- match self {
- '0' ... '9' => true,
- c if c > '\x7f' => general_category::N(c),
- _ => false
- }
- }
-
- #[inline]
- fn to_lowercase(self) -> ToLowercase {
- ToLowercase(Some(conversions::to_lower(self)))
- }
-
- #[inline]
- fn to_uppercase(self) -> ToUppercase {
- ToUppercase(Some(conversions::to_upper(self)))
- }
-
- #[inline]
- fn width(self, is_cjk: bool) -> Option<usize> { charwidth::width(self, is_cjk) }
-}
-
/// An iterator over the lowercase mapping of a given character, returned from
/// the [`to_lowercase` method](../primitive.char.html#method.to_lowercase) on
/// characters.
use core::cmp;
use core::iter::{Filter, AdditiveIterator};
use core::mem;
-use core::num::Int;
use core::slice;
use core::str::Split;
-Subproject commit 60fd8abfcae50629a3fc664bd809238fed039617
+Subproject commit 49cc7f6fef12bdd77a0f8b182d9a64c371cb17c8
+S 2015-03-25 a923278
+ bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163
+ freebsd-x86_64 cd02c86a9218da73b2a45aff293787010d33bf3e
+ linux-i386 da50141558eed6dabab97b79b2c6a7de4f2d2c5e
+ linux-x86_64 bca03458d28d07506bad4b80e5770b2117286244
+ macos-i386 522d59b23dd885a45e2c5b33e80e76240bb2d9af
+ macos-x86_64 82df09d51d73d119a2f4e4d8041879615cb22081
+ winnt-i386 5056e8def5ab4f4283b8f3aab160cc10231bb28d
+ winnt-x86_64 3f6b35ac12625b4b4b42dfd5eee5f6cbf122794e
+
S 2015-03-17 c64d671
bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163
freebsd-x86_64 14ced24e1339a4dd8baa9db69995daa52a948d54
// except according to those terms.
trait me {
- fn me(&self) -> uint;
+ fn me(&self) -> usize;
}
-impl me for uint { fn me(&self) -> uint { *self } }
+impl me for usize { fn me(&self) -> usize { *self } }
// except according to those terms.
pub struct Foo {
- pub x: int
+ pub x: isize
}
impl Foo {
fn get(x: Option<Self>) -> <Self as Bar>::T;
}
-impl Bar for int {
- type T = uint;
+impl Bar for isize {
+ type T = usize;
- fn get(_: Option<int>) -> uint { 22 }
+ fn get(_: Option<isize>) -> usize { 22 }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn foo(x: &uint) -> uint {
+pub fn foo(x: &usize) -> usize {
*x
}
pub mod kitties {
pub struct cat {
- meows : uint,
+ meows : usize,
- pub how_hungry : int,
+ pub how_hungry : isize,
}
- pub fn cat(in_x : uint, in_y : int) -> cat {
+ pub fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
pub mod kitties {
pub struct cat {
- meows : uint,
+ meows : usize,
- pub how_hungry : int,
+ pub how_hungry : isize,
}
pub fn speak(&self) {}
}
- pub fn cat(in_x : uint, in_y : int) -> cat {
+ pub fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
pub mod kitties {
pub struct cat {
- meows : uint,
+ meows : usize,
- pub how_hungry : int,
+ pub how_hungry : isize,
}
impl cat {
pub fn speak(&mut self) { self.meows += 1; }
- pub fn meow_count(&mut self) -> uint { self.meows }
+ pub fn meow_count(&mut self) -> usize { self.meows }
}
- pub fn cat(in_x : uint, in_y : int) -> cat {
+ pub fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
pub mod kitties {
pub struct cat {
- meows : uint,
+ meows : usize,
- pub how_hungry : int,
+ pub how_hungry : isize,
pub name : String,
}
}
}
- pub fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+ pub fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
pub mod kitties {
pub struct cat {
- meows : uint,
- pub how_hungry : int,
+ meows : usize,
+ pub how_hungry : isize,
}
impl cat {
fn nap(&self) {}
}
- pub fn cat(in_x : uint, in_y : int) -> cat {
+ pub fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
pub struct cat<U> {
info : Vec<U> ,
- meows : uint,
+ meows : usize,
- pub how_hungry : int,
+ pub how_hungry : isize,
}
impl<U> cat<U> {
self.meows += stuff.len();
}
- pub fn meow_count(&mut self) -> uint { self.meows }
+ pub fn meow_count(&mut self) -> usize { self.meows }
}
- pub fn cat<U>(in_x : uint, in_y : int, in_info: Vec<U> ) -> cat<U> {
+ pub fn cat<U>(in_x : usize, in_y : isize, in_info: Vec<U> ) -> cat<U> {
cat {
meows: in_x,
how_hungry: in_y,
use std::fmt;
pub struct cat {
- meows : uint,
- pub how_hungry : int,
+ meows : usize,
+ pub how_hungry : isize,
pub name : String,
}
}
}
- pub fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+ pub fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
}
pub const foopy: &'static str = "hi there";
-pub const uint_val: uint = 12;
-pub const uint_expr: uint = (1 << uint_val) - 1;
+pub const uint_val: usize = 12;
+pub const uint_expr: usize = (1 << uint_val) - 1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub static BLOCK_FN_DEF: fn(uint) -> uint = {
- fn foo(a: uint) -> uint {
+pub static BLOCK_FN_DEF: fn(usize) -> usize = {
+ fn foo(a: usize) -> usize {
a + 10
}
foo
#![crate_name="cci_impl_lib"]
pub trait uint_helpers {
- fn to<F>(&self, v: uint, f: F) where F: FnMut(uint);
+ fn to<F>(&self, v: usize, f: F) where F: FnMut(usize);
}
-impl uint_helpers for uint {
+impl uint_helpers for usize {
#[inline]
- fn to<F>(&self, v: uint, mut f: F) where F: FnMut(uint) {
+ fn to<F>(&self, v: usize, mut f: F) where F: FnMut(usize) {
let mut i = *self;
while i < v {
f(i);
}
#[inline(always)]
-pub fn atomic_xchg(dst: *mut int, src: int) -> int {
+pub fn atomic_xchg(dst: *mut isize, src: isize) -> isize {
unsafe {
rusti::atomic_xchg(dst, src)
}
}
#[inline]
-pub fn new_int_alist<B:'static>() -> alist<int, B> {
- fn eq_int(a: int, b: int) -> bool { a == b }
+pub fn new_int_alist<B:'static>() -> alist<isize, B> {
+ fn eq_int(a: isize, b: isize) -> bool { a == b }
return alist {
eq_fn: eq_int,
data: box RefCell::new(Vec::new()),
}
#[inline]
-pub fn new_int_alist_2<B:'static>() -> alist<int, B> {
+pub fn new_int_alist_2<B:'static>() -> alist<isize, B> {
#[inline]
- fn eq_int(a: int, b: int) -> bool { a == b }
+ fn eq_int(a: isize, b: isize) -> bool { a == b }
return alist {
eq_fn: eq_int,
data: box RefCell::new(Vec::new()),
// same as cci_iter_lib, more-or-less, but not marked inline
-pub fn iter<F>(v: Vec<uint> , mut f: F) where F: FnMut(uint) {
+pub fn iter<F>(v: Vec<usize> , mut f: F) where F: FnMut(usize) {
let mut i = 0;
let n = v.len();
while i < n {
// this used to just ICE on compiling
pub fn foo() {
if cfg!(foo) {
- static a: int = 3;
+ static a: isize = 3;
a
} else { 3 };
}
extern crate a;
-pub fn foo() { a::foo::<int>(); }
+pub fn foo() { a::foo::<isize>(); }
#![crate_name = "crateresolve1"]
#![crate_type = "lib"]
-pub fn f() -> int { 10 }
+pub fn f() -> isize { 10 }
#![crate_name = "crateresolve1"]
#![crate_type = "lib"]
-pub fn f() -> int { 20 }
+pub fn f() -> isize { 20 }
#![crate_name = "crateresolve1"]
#![crate_type = "lib"]
-pub fn f() -> int { 30 }
+pub fn f() -> isize { 30 }
#![crate_type = "lib"]
-pub fn f() -> int { 10 }
+pub fn f() -> isize { 10 }
#![crate_type = "lib"]
-pub fn g() -> int { 20 }
+pub fn g() -> isize { 20 }
#![crate_name="crateresolve4a#0.1"]
#![crate_type = "lib"]
-pub fn f() -> int { 10 }
+pub fn f() -> isize { 10 }
#![crate_name="crateresolve4a#0.2"]
#![crate_type = "lib"]
-pub fn g() -> int { 20 }
+pub fn g() -> isize { 20 }
extern crate "crateresolve4a#0.2" as crateresolve4a;
-pub fn f() -> int { crateresolve4a::g() }
+pub fn f() -> isize { crateresolve4a::g() }
extern crate "crateresolve4a#0.1" as crateresolve4a;
-pub fn g() -> int { crateresolve4a::f() }
+pub fn g() -> isize { crateresolve4a::f() }
#![crate_type = "lib"]
-pub struct NameVal { pub name: String, pub val: int }
+pub struct NameVal { pub name: String, pub val: isize }
pub fn struct_nameval() -> NameVal {
NameVal { name: "crateresolve5".to_string(), val: 10 }
fn ne(&self, other: &e) -> bool { !nominal_eq(*self, *other) }
}
-pub fn f() -> int { 10 }
+pub fn f() -> isize { 10 }
#![crate_type = "lib"]
-pub struct NameVal { pub name: String, pub val: int }
+pub struct NameVal { pub name: String, pub val: isize }
pub fn struct_nameval() -> NameVal {
NameVal { name: "crateresolve5".to_string(), val: 10 }
}
pub fn nominal_neq(_e1: e, _e2: e) -> bool { false }
-pub fn f() -> int { 20 }
+pub fn f() -> isize { 20 }
// These both have the same version but differ in other metadata
pub mod a {
extern crate cr_1 (name = "crateresolve_calories", vers = "0.1", calories="100");
- pub fn f() -> int { cr_1::f() }
+ pub fn f() -> isize { cr_1::f() }
}
pub mod b {
extern crate cr_2 (name = "crateresolve_calories", vers = "0.1", calories="200");
- pub fn f() -> int { cr_2::f() }
+ pub fn f() -> isize { cr_2::f() }
}
#![crate_type = "lib"]
-pub fn f() -> int { 20 }
+pub fn f() -> isize { 20 }
#![crate_name="crateresolve_calories#0.1"]
#![crate_type = "lib"]
-pub fn f() -> int { 100 }
+pub fn f() -> isize { 100 }
#![crate_name="crateresolve_calories#0.1"]
#![crate_type = "lib"]
-pub fn f() -> int { 200 }
+pub fn f() -> isize { 200 }
#[inline(never)]
#[cfg(target_arch = "x86_64")]
-pub extern "win64" fn foo(a: int, b: int, c: int, d: int) {
+pub extern "win64" fn foo(a: isize, b: isize, c: isize, d: isize) {
assert!(a == 1);
assert!(b == 2);
assert!(c == 3);
#[inline(never)]
#[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "aarch64"))]
-pub extern fn foo(a: int, b: int, c: int, d: int) {
+pub extern fn foo(a: isize, b: isize, c: isize, d: isize) {
assert!(a == 1);
assert!(b == 2);
assert!(c == 3);
// Common code used for tests that model the Fn/FnMut/FnOnce hierarchy.
pub trait Go {
- fn go(&self, arg: int);
+ fn go(&self, arg: isize);
}
-pub fn go<G:Go>(this: &G, arg: int) {
+pub fn go<G:Go>(this: &G, arg: isize) {
this.go(arg)
}
pub trait GoMut {
- fn go_mut(&mut self, arg: int);
+ fn go_mut(&mut self, arg: isize);
}
-pub fn go_mut<G:GoMut>(this: &mut G, arg: int) {
+pub fn go_mut<G:GoMut>(this: &mut G, arg: isize) {
this.go_mut(arg)
}
pub trait GoOnce {
- fn go_once(self, arg: int);
+ fn go_once(self, arg: isize);
}
-pub fn go_once<G:GoOnce>(this: G, arg: int) {
+pub fn go_once<G:GoOnce>(this: G, arg: isize) {
this.go_once(arg)
}
impl<G> GoMut for G
where G : Go
{
- fn go_mut(&mut self, arg: int) {
+ fn go_mut(&mut self, arg: isize) {
go(&*self, arg)
}
}
impl<G> GoOnce for G
where G : GoMut
{
- fn go_once(mut self, arg: int) {
+ fn go_once(mut self, arg: isize) {
go_mut(&mut self, arg)
}
}
#![crate_type = "lib"]
pub struct Fish {
- pub x: int
+ pub x: isize
}
impl Fish {
#![crate_type = "lib"]
pub struct Fish {
- pub x: int
+ pub x: isize
}
mod unexported {
#![feature(struct_inherit)]
pub virtual struct S1 {
- pub f1: int,
+ pub f1: isize,
}
pub struct S2 : S1 {
- pub f2: int,
+ pub f2: isize,
}
pub fn test_s2(s2: S2) {
fn stable(&self);
}
-impl Stable for uint {
+impl Stable for usize {
fn unstable(&self) {}
fn stable(&self) {}
}
pub struct A<T> { pub v: T }
impl<T> A<T> {
- pub fn foo(&self) -> int {
- static a: int = 5;
+ pub fn foo(&self) -> isize {
+ static a: isize = 5;
return a
}
- pub fn bar(&self) -> int {
- static a: int = 6;
+ pub fn bar(&self) -> isize {
+ static a: isize = 6;
return a;
}
}
}
impl<T> A<T> {
- pub fn foo(&self) -> int {
- static a: int = 1;
+ pub fn foo(&self) -> isize {
+ static a: isize = 1;
return a
}
- pub fn bar(&self) -> int {
- static a: int = 2;
+ pub fn bar(&self) -> isize {
+ static a: isize = 2;
return a;
}
}
impl<T> B<T> {
- pub fn foo(&self) -> int {
- static a: int = 3;
+ pub fn foo(&self) -> isize {
+ static a: isize = 3;
return a
}
- pub fn bar(&self) -> int {
- static a: int = 4;
+ pub fn bar(&self) -> isize {
+ static a: isize = 4;
return a;
}
}
-pub fn foo() -> int {
+pub fn foo() -> isize {
let a = A { v: () };
let b = B { v: () };
let c = test::A { v: () };
fn f(&self) { f(); }
}
- impl Trait for int {}
+ impl Trait for isize {}
fn f() {}
}
pub fn foo() {
- let a = &1i as &inner::Trait;
+ let a = &1is as &inner::Trait;
a.f();
}
fn f(&self) { f(); }
}
- impl Trait for int {}
+ impl Trait for isize {}
fn f() {}
}
fn foo<T: Trait>(&self, t: T) { t.f(); }
}
-impl Outer for int {}
+impl Outer for isize {}
pub fn foo<T: Outer>(t: T) {
t.foo(inner::Foo);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub struct A<'a>(pub &'a int);
+pub struct A<'a>(pub &'a isize);
#![crate_type = "dylib"]
-extern crate "issue-12133-rlib" as a;
-extern crate "issue-12133-dylib" as b;
+extern crate issue_12133_rlib as a;
+extern crate issue_12133_dylib as b;
#![crate_type = "rlib"]
-#[macro_use] #[no_link] extern crate "issue-13560-1" as t1;
-#[macro_use] extern crate "issue-13560-2" as t2;
+#[macro_use] #[no_link] extern crate issue_13560_1 as t1;
+#[macro_use] extern crate issue_13560_2 as t2;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-extern crate "issue-13620-1" as crate1;
+extern crate issue_13620_1 as crate1;
pub static FOO2: crate1::Foo = crate1::FOO;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-extern crate "issue-13872-1" as foo;
+extern crate issue_13872_1 as foo;
pub use foo::A::B;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-extern crate "issue-13872-2" as bar;
+extern crate issue_13872_2 as bar;
use bar::B;
use std::sync::atomic;
-pub const C1: uint = 1;
+pub const C1: usize = 1;
pub const C2: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
pub const C3: fn() = foo;
-pub const C4: uint = C1 * C1 + C1 / C1;
-pub const C5: &'static uint = &C4;
+pub const C4: usize = C1 * C1 + C1 / C1;
+pub const C5: &'static usize = &C4;
-pub static S1: uint = 3;
+pub static S1: usize = 3;
pub static S2: atomic::AtomicUsize = atomic::ATOMIC_USIZE_INIT;
fn foo() {}
#![crate_name="a"]
#![crate_type = "lib"]
-type t1 = uint;
+type t1 = usize;
trait foo {
fn foo(&self);
use std::marker;
struct arc_destruct<T: Sync> {
- _data: int,
+ _data: isize,
_marker: marker::PhantomData<T>
}
fn drop(&mut self) {}
}
-fn arc_destruct<T: Sync>(data: int) -> arc_destruct<T> {
+fn arc_destruct<T: Sync>(data: isize) -> arc_destruct<T> {
arc_destruct {
_data: data,
_marker: marker::PhantomData
}
struct context_res {
- ctx : int,
+ ctx : isize,
}
impl Drop for context_res {
use std::collections::HashMap;
-pub type map = Box<HashMap<uint, uint>>;
+pub type map = Box<HashMap<usize, usize>>;
}
fn main() {
- BTree::<int> { node: leaf(1) };
+ BTree::<isize> { node: leaf(1) };
}
pub use other::foo;
mod other {
- pub struct FooBar{value: int}
+ pub struct FooBar{value: isize}
impl FooBar{
- pub fn new(val: int) -> FooBar {
+ pub fn new(val: isize) -> FooBar {
FooBar{value: val}
}
}
pub type FooChar = char;
// Tests ty_int (does not test all variants of IntTy)
- pub type FooInt = int;
+ pub type FooInt = isize;
// Tests ty_uint (does not test all variants of UintTy)
- pub type FooUint = uint;
+ pub type FooUint = usize;
// Tests ty_float (does not test all variants of FloatTy)
pub type FooFloat = f64;
// Tests ty_enum
pub enum FooEnum {
- VarA(uint),
- VarB(uint, uint)
+ VarA(usize),
+ VarB(usize, usize)
}
// Tests ty_uniq (of u8)
// Tests ty_trait
pub trait FooTrait {
- fn foo_method(&self) -> uint;
- fn foo_static_method() -> uint;
+ fn foo_method(&self) -> usize;
+ fn foo_static_method() -> usize;
}
// Tests ty_struct
pub struct FooStruct {
- pub pub_foo_field: uint,
- foo_field: uint
+ pub pub_foo_field: usize,
+ foo_field: usize
}
// Tests ty_tup
// except according to those terms.
enum Foo {
- Bar(int)
+ Bar(isize)
}
pub mod test {
enum Foo {
- Bar(int)
+ Bar(isize)
}
}
pub use foo::FOO2;
-pub const FOO: uint = 3;
-const BAR: uint = 3;
+pub const FOO: usize = 3;
+const BAR: usize = 3;
mod foo {
- pub const FOO2: uint = 3;
+ pub const FOO2: usize = 3;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub struct Foo (pub int);
+pub struct Foo (pub isize);
pub enum MyEnum {
Foo(Foo),
}
// except according to those terms.
-pub unsafe fn f(xs: Vec<int> ) {
+pub unsafe fn f(xs: Vec<isize> ) {
xs.iter().map(|_x| { unsafe fn q() { panic!(); } }).collect::<Vec<()>>();
}
#![crate_type = "lib"]
pub trait Positioned {
- fn SetX(&mut self, int);
- fn X(&self) -> int;
+ fn SetX(&mut self, isize);
+ fn X(&self) -> isize;
}
pub trait Movable: Positioned {
- fn translate(&mut self, dx: int) {
+ fn translate(&mut self, dx: isize) {
let x = self.X() + dx;
self.SetX(x);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn foo<T>() -> &'static int {
+pub fn foo<T>() -> &'static isize {
if false {
- static a: int = 4;
+ static a: isize = 4;
return &a;
} else {
- static a: int = 5;
+ static a: isize = 5;
return &a;
}
}
-pub fn bar() -> &'static int {
- foo::<int>()
+pub fn bar() -> &'static isize {
+ foo::<isize>()
}
pub trait Sized : PhantomFn<Self> {}
#[lang="panic"]
-fn panic(_: &(&'static str, &'static str, uint)) -> ! { loop {} }
+fn panic(_: &(&'static str, &'static str, usize)) -> ! { loop {} }
#[lang = "stack_exhausted"]
extern fn stack_exhausted() {}
pub trait Copy : PhantomFn<Self> {
// Empty.
}
+
+#[lang="rem"]
+pub trait Rem<RHS=Self> {
+ type Output = Self;
+ fn rem(self, rhs: RHS) -> Self::Output;
+}
+
+impl Rem for isize {
+ type Output = isize;
+
+ #[inline]
+ fn rem(self, other: isize) -> isize {
+ // if you use `self % other` here, as one would expect, you
+ // get back an error because of potential failure/overflow,
+ // which tries to invoke error fns that don't have the
+ // appropriate signatures anymore. So...just return 0.
+ 0
+ }
+}
pub fn test() {
let lib = DynamicLibrary::open(None).unwrap();
unsafe {
- assert!(lib.symbol::<int>("foo").is_ok());
- assert!(lib.symbol::<int>("baz").is_err());
- assert!(lib.symbol::<int>("bar").is_err());
+ assert!(lib.symbol::<isize>("foo").is_ok());
+ assert!(lib.symbol::<isize>("baz").is_err());
+ assert!(lib.symbol::<isize>("bar").is_err());
}
}
// except according to those terms.
#[no_mangle]
-pub static foo: int = 3;
+pub static foo: isize = 3;
pub fn bar() {}
#[stable(feature = "test_feature", since = "1.0.0")]
#[deprecated(since = "1.0.0")]
-pub fn foo() -> uint {
+pub fn foo() -> usize {
20
}
#[unstable(feature = "test_feature")]
-pub fn bar() -> uint {
+pub fn bar() -> usize {
40
}
#[unstable(feature = "test_feature")]
-pub fn baz() -> uint {
+pub fn baz() -> usize {
30
}
#[stable(feature = "test_feature", since = "1.0.0")]
#[deprecated(since = "1.0.0")]
pub struct DeprecatedStruct {
- #[stable(feature = "test_feature", since = "1.0.0")] pub i: int
+ #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize
}
#[unstable(feature = "test_feature")]
#[deprecated(since = "1.0.0")]
pub struct DeprecatedUnstableStruct {
- #[stable(feature = "test_feature", since = "1.0.0")] pub i: int
+ #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize
}
#[unstable(feature = "test_feature")]
pub struct UnstableStruct {
- #[stable(feature = "test_feature", since = "1.0.0")] pub i: int
+ #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize
}
#[stable(feature = "rust1", since = "1.0.0")]
pub struct StableStruct {
- #[stable(feature = "test_feature", since = "1.0.0")] pub i: int
+ #[stable(feature = "test_feature", since = "1.0.0")] pub i: isize
}
#[stable(feature = "test_feature", since = "1.0.0")]
#[stable(feature = "test_feature", since = "1.0.0")]
#[deprecated(since = "1.0.0")]
-pub struct DeprecatedTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int);
+pub struct DeprecatedTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize);
#[unstable(feature = "test_feature")]
#[deprecated(since = "1.0.0")]
-pub struct DeprecatedUnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int);
+pub struct DeprecatedUnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize);
#[unstable(feature = "test_feature")]
-pub struct UnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int);
+pub struct UnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize);
#[stable(feature = "rust1", since = "1.0.0")]
-pub struct StableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub int);
+pub struct StableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize);
#[macro_export]
macro_rules! macro_test {
#[macro_use] extern crate log;
pub fn foo<T>() {
- fn death() -> int { panic!() }
+ fn death() -> isize { panic!() }
debug!("{}", (||{ death() })());
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn increment(x: uint) -> uint {
+pub fn increment(x: usize) -> usize {
x + 1
}
#![crate_type="lib"]
pub struct S {
- x: int,
+ x: isize,
}
impl Drop for S {
pub enum Foo {
A,
- B(int),
- C { a: int },
+ B(isize),
+ C { a: isize },
}
impl Foo {
pub enum Bar {
D,
- E(int),
- F { a: int },
+ E(isize),
+ F { a: isize },
}
impl Bar {
pub enum Foo {
A,
- B(int),
- C { a: int },
+ B(isize),
+ C { a: isize },
}
impl Foo {
// except according to those terms.
// original problem
-pub fn foo<T>() -> int {
+pub fn foo<T>() -> isize {
{
- static foo: int = 2;
+ static foo: isize = 2;
foo
}
}
struct Foo;
impl Foo {
pub fn foo<T>(&self) {
- static X: uint = 1;
+ static X: usize = 1;
}
}
struct Bar;
impl Foo {
pub fn bar<T>(&self) {
- static X: uint = 1;
+ static X: usize = 1;
}
}
#![crate_type="lib"]
-pub struct Au(pub int);
+pub struct Au(pub isize);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub type oint = Option<int>;
+pub type oint = Option<isize>;
pub fn foo() -> oint { Some(3) }
use rustc::plugin::Registry;
struct Foo {
- foo: int
+ foo: isize
}
impl Drop for Foo {
fn frob(&self);
}
-impl A for int { fn frob(&self) {} }
+impl A for isize { fn frob(&self) {} }
pub fn frob<T:A>(t: T) {
t.frob();
// except according to those terms.
pub struct A(());
-pub struct B(int);
-pub struct C(pub int, int);
-pub struct D(pub int);
+pub struct B(isize);
+pub struct C(pub isize, isize);
+pub struct D(pub isize);
// except according to those terms.
pub struct Foo {
- pub name: int
+ pub name: isize
}
fn bar() -> Self;
}
-impl Bar for int {
- fn bar() -> int { 84 }
+impl Bar for isize {
+ fn bar() -> isize { 84 }
}
pub mod sub_foo {
fn foo() -> Self;
}
- impl Foo for int {
- fn foo() -> int { 42 }
+ impl Foo for isize {
+ fn foo() -> isize { 42 }
}
pub struct Boz {
}
impl Boz {
- pub fn boz(i: int) -> bool {
+ pub fn boz(i: isize) -> bool {
i > 0
}
}
// scenario work. This is the library portion of the test.
pub enum MaybeOwned<'a> {
- Owned(int),
- Borrowed(&'a int)
+ Owned(isize),
+ Borrowed(&'a isize)
}
pub struct Inv<'a> { // invariant w/r/t 'a
- x: &'a mut &'a int
+ x: &'a mut &'a isize
}
// I encountered a bug at some point with encoding the IntoMaybeOwned
#![crate_type="dylib"]
#![feature(plugin_registrar, rustc_private)]
+#![feature(slice_patterns)]
extern crate syntax;
extern crate rustc;
fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
-> Box<MacResult + 'static> {
- static NUMERALS: &'static [(&'static str, uint)] = &[
+ static NUMERALS: &'static [(&'static str, usize)] = &[
("M", 1000), ("CM", 900), ("D", 500), ("CD", 400),
("C", 100), ("XC", 90), ("L", 50), ("XL", 40),
("X", 10), ("IX", 9), ("V", 5), ("IV", 4),
// except according to those terms.
#[no_mangle]
-pub extern "C" fn foo() -> uint {
+pub extern "C" fn foo() -> usize {
1234
}
// except according to those terms.
#[inline]
-pub fn cci_fn() -> uint {
+pub fn cci_fn() -> usize {
1200
}
#[inline]
-pub static CCI_STATIC: uint = 34;
+pub static CCI_STATIC: usize = 34;
// compile-flags: -C codegen-units=3 --crate-type=rlib,dylib
pub mod a {
- pub fn one() -> uint {
+ pub fn one() -> usize {
1
}
}
pub mod b {
- pub fn two() -> uint {
+ pub fn two() -> usize {
2
}
}
pub mod c {
use a::one;
use b::two;
- pub fn three() -> uint {
+ pub fn three() -> usize {
one() + two()
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![crate_name="static-function-pointer-aux"]
-pub fn f(x: int) -> int { -x }
+pub fn f(x: isize) -> isize { -x }
-pub static F: fn(int) -> int = f;
-pub static mut MutF: fn(int) -> int = f;
+pub static F: fn(isize) -> isize = f;
+pub static mut MutF: fn(isize) -> isize = f;
pub mod num {
pub trait Num2 {
- fn from_int2(n: int) -> Self;
+ fn from_int2(n: isize) -> Self;
}
}
pub mod f64 {
impl ::num::Num2 for f64 {
#[inline]
- fn from_int2(n: int) -> f64 { return n as f64; }
+ fn from_int2(n: isize) -> f64 { return n as f64; }
}
}
pub mod num {
pub trait Num2 {
- fn from_int2(n: int) -> Self;
+ fn from_int2(n: isize) -> Self;
}
}
pub mod f64 {
impl ::num::Num2 for f64 {
- fn from_int2(n: int) -> f64 { return n as f64; }
+ fn from_int2(n: isize) -> f64 { return n as f64; }
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub static mut a: int = 3;
+pub static mut a: isize = 3;
#![crate_type = "lib"]
-static private: int = 0;
-pub static public: int = 0;
+static private: isize = 0;
+pub static public: isize = 0;
pub struct A(());
}
mod foo {
- pub static a: int = 0;
+ pub static a: isize = 0;
pub fn b() {}
pub struct c;
pub enum d {}
- pub type e = int;
+ pub type e = isize;
pub struct A(());
}
// these are public so the parent can reexport them.
- pub static reexported_a: int = 0;
+ pub static reexported_a: isize = 0;
pub fn reexported_b() {}
pub struct reexported_c;
pub enum reexported_d {}
- pub type reexported_e = int;
+ pub type reexported_e = isize;
}
pub mod bar {
pub use foo::reexported_e as i;
}
-pub static a: int = 0;
+pub static a: isize = 0;
pub fn b() {}
pub struct c;
pub enum d {}
-pub type e = int;
+pub type e = isize;
-static j: int = 0;
+static j: isize = 0;
fn k() {}
struct l;
enum m {}
-type n = int;
+type n = isize;
#![crate_type="lib"]
pub struct S {
- pub x: int,
- pub y: int,
+ pub x: isize,
+ pub y: isize,
}
// except according to those terms.
struct A {
- a: int,
- pub b: int,
+ a: isize,
+ pub b: isize,
}
pub struct B {
- pub a: int,
- b: int,
+ pub a: isize,
+ b: isize,
}
// except according to those terms.
enum Bar {
- Baz { a: int }
+ Baz { a: isize }
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
0
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
#[cfg(some_flag)]
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
#[cfg(not(some_flag))]
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:V>(_: int) -> int {
+pub fn foo<T:V>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: i32) -> int {
+pub fn foo<T:U>(_: i32) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> i64 {
+pub fn foo<T:U>(_: isize) -> i64 {
3
}
static A_CONSTANT : i32 = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
// a comment does not affect the svh
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
// Adding some documentation does not affect the svh.
/// foo always returns three.
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
// a macro invocation in a function body does not affect the svh,
// as long as it yields the same code.
three!()
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
// cfg attribute does not affect the svh, as long as it yields the same code.
#[cfg(not(an_unused_name))]
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
impl U for () {}
impl V for () {}
-static A_CONSTANT : int = 2;
+static A_CONSTANT : isize = 2;
-pub fn foo<T:U>(_: int) -> int {
+pub fn foo<T:U>(_: isize) -> isize {
3
}
-pub fn an_unused_name() -> int {
+pub fn an_unused_name() -> isize {
4
}
#![crate_name = "uta"]
mod traits {
- pub trait TraitA { fn val(&self) -> int { 2 } }
- pub trait TraitB { fn val(&self) -> int { 3 } }
+ pub trait TraitA { fn val(&self) -> isize { 2 } }
+ pub trait TraitB { fn val(&self) -> isize { 3 } }
}
impl traits::TraitA for () {}
impl traits::TraitB for () {}
-pub fn foo<T>(_: int) -> int {
+pub fn foo<T>(_: isize) -> isize {
use traits::TraitA;
let v = ();
v.val()
#![crate_name = "uta"]
mod traits {
- pub trait TraitA { fn val(&self) -> int { 2 } }
- pub trait TraitB { fn val(&self) -> int { 3 } }
+ pub trait TraitA { fn val(&self) -> isize { 2 } }
+ pub trait TraitB { fn val(&self) -> isize { 3 } }
}
impl traits::TraitA for () {}
impl traits::TraitB for () {}
-pub fn foo<T>(_: int) -> int {
+pub fn foo<T>(_: isize) -> isize {
use traits::TraitB;
let v = ();
v.val()
#![crate_type = "dylib"]
-pub fn the_answer() -> int {
+pub fn the_answer() -> isize {
2
}
#![crate_type = "dylib"]
#![feature(plugin_registrar, quote, rustc_private)]
-extern crate "syntax_extension_with_dll_deps_1" as other;
+extern crate syntax_extension_with_dll_deps_1 as other;
extern crate syntax;
extern crate rustc;
}
pub enum Bar<T:Trait> {
- ABar(int),
+ ABar(isize),
BBar(T),
- CBar(uint),
+ CBar(usize),
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![crate_name="trait_default_method_xc_aux"]
-
-pub struct Something { pub x: int }
+pub struct Something { pub x: isize }
pub trait A {
- fn f(&self) -> int;
- fn g(&self) -> int { 10 }
- fn h(&self) -> int { 11 }
- fn lurr(x: &Self, y: &Self) -> int { x.g() + y.h() }
+ fn f(&self) -> isize;
+ fn g(&self) -> isize { 10 }
+ fn h(&self) -> isize { 11 }
+ fn lurr(x: &Self, y: &Self) -> isize { x.g() + y.h() }
}
-impl A for int {
- fn f(&self) -> int { 10 }
+impl A for isize {
+ fn f(&self) -> isize { 10 }
}
impl A for Something {
- fn f(&self) -> int { 10 }
+ fn f(&self) -> isize { 10 }
}
pub trait B<T> {
fn staticthing<U>(_z: &Self, x: T, y: U) -> (T, U) { (x, y) }
}
-impl<T> B<T> for int { }
+impl<T> B<T> for isize { }
impl B<f64> for bool { }
}
}
-impl TestEquality for int {
- fn test_eq(&self, rhs: &int) -> bool {
+impl TestEquality for isize {
+ fn test_eq(&self, rhs: &isize) -> bool {
*self == *rhs
}
}
// aux-build:trait_default_method_xc_aux.rs
-extern crate "trait_default_method_xc_aux" as aux;
+extern crate trait_default_method_xc_aux as aux;
use aux::A;
-pub struct a_struct { pub x: int }
+pub struct a_struct { pub x: isize }
impl A for a_struct {
- fn f(&self) -> int { 10 }
+ fn f(&self) -> isize { 10 }
}
// This function will need to get inlined, and badness may result.
pub trait Foo : ::std::marker::MarkerTrait {
}
-impl Foo for int {
+impl Foo for isize {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub trait Foo { fn f(&self) -> int; }
-pub trait Bar { fn g(&self) -> int; }
-pub trait Baz { fn h(&self) -> int; }
+pub trait Foo { fn f(&self) -> isize; }
+pub trait Bar { fn g(&self) -> isize; }
+pub trait Baz { fn h(&self) -> isize; }
-pub struct A { pub x: int }
+pub struct A { pub x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
-impl Baz for A { fn h(&self) -> int { 30 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
+impl Baz for A { fn h(&self) -> isize { 30 } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub trait Foo { fn f(&self) -> int; }
-pub trait Bar { fn g(&self) -> int; }
-pub trait Baz { fn h(&self) -> int; }
+pub trait Foo { fn f(&self) -> isize; }
+pub trait Bar { fn g(&self) -> isize; }
+pub trait Baz { fn h(&self) -> isize; }
pub trait Quux: Foo + Bar + Baz { }
pub trait Foo {
- fn f(&self) -> int;
+ fn f(&self) -> isize;
}
pub struct A {
- pub x: int
+ pub x: isize
}
impl Foo for A {
- fn f(&self) -> int { 10 }
+ fn f(&self) -> isize { 10 }
}
#[derive(Clone, Debug)]
pub struct MyInt {
- pub val: int
+ pub val: isize
}
impl Add for MyInt {
impl MyNum for MyInt {}
-fn mi(v: int) -> MyInt { MyInt { val: v } }
+fn mi(v: isize) -> MyInt { MyInt { val: v } }
// Simple smoke test that unsafe traits can be compiled etc.
pub unsafe trait Foo {
- fn foo(&self) -> int;
+ fn foo(&self) -> isize;
}
-unsafe impl Foo for int {
- fn foo(&self) -> int { *self }
+unsafe impl Foo for isize {
+ fn foo(&self) -> isize { *self }
}
#![feature(core)]
-use std::any::TypeId;
+use std::any::{Any, TypeId};
pub struct A;
pub struct B(Option<A>);
-pub struct C(Option<int>);
+pub struct C(Option<isize>);
pub struct D(Option<&'static str>);
-pub struct E(Result<&'static str, int>);
+pub struct E(Result<&'static str, isize>);
-pub type F = Option<int>;
-pub type G = uint;
+pub type F = Option<isize>;
+pub type G = usize;
pub type H = &'static str;
pub unsafe fn id_A() -> TypeId { TypeId::of::<A>() }
pub unsafe fn id_G() -> TypeId { TypeId::of::<G>() }
pub unsafe fn id_H() -> TypeId { TypeId::of::<H>() }
-pub unsafe fn foo<T: 'static>() -> TypeId { TypeId::of::<T>() }
+pub unsafe fn foo<T: Any>() -> TypeId { TypeId::of::<T>() }
#![feature(core)]
-use std::any::TypeId;
+use std::any::{Any, TypeId};
pub struct A;
pub struct B(Option<A>);
-pub struct C(Option<int>);
+pub struct C(Option<isize>);
pub struct D(Option<&'static str>);
-pub struct E(Result<&'static str, int>);
+pub struct E(Result<&'static str, isize>);
-pub type F = Option<int>;
-pub type G = uint;
+pub type F = Option<isize>;
+pub type G = usize;
pub type H = &'static str;
pub unsafe fn id_A() -> TypeId { TypeId::of::<A>() }
pub unsafe fn id_G() -> TypeId { TypeId::of::<G>() }
pub unsafe fn id_H() -> TypeId { TypeId::of::<H>() }
-pub unsafe fn foo<T: 'static>() -> TypeId { TypeId::of::<T>() }
+pub unsafe fn foo<T:Any>() -> TypeId { TypeId::of::<T>() }
use std::ops::Add;
#[inline]
-pub fn has_closures() -> uint {
+pub fn has_closures() -> usize {
let x = 1;
let mut f = move || x;
let y = 1;
#![crate_type="lib"]
pub struct Struct {
- pub x: int
+ pub x: isize
}
impl Struct {
Struct { x: 1 }
}
- fn meth_struct(&self) -> int {
+ fn meth_struct(&self) -> isize {
self.x
}
}
pub enum Enum {
- Variant1(int),
- Variant2(int)
+ Variant1(isize),
+ Variant2(isize)
}
impl Enum {
Enum::Variant2(10)
}
- fn meth_enum(&self) -> int {
+ fn meth_enum(&self) -> isize {
match *self {
Enum::Variant1(x) |
Enum::Variant2(x) => x
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn foo<T>() -> int {
- static a: int = 3;
+pub fn foo<T>() -> isize {
+ static a: isize = 3;
a
}
-pub fn bar() -> int {
- foo::<int>()
+pub fn bar() -> isize {
+ foo::<isize>()
}
// except according to those terms.
#[inline(never)]
-pub static global: int = 3;
+pub static global: isize = 3;
#[inline(never)]
-static global0: int = 4;
+static global0: isize = 4;
#[inline(never)]
-pub static global2: &'static int = &global0;
+pub static global2: &'static isize = &global0;
-pub fn verify_same(a: &'static int) {
- let a = a as *const int as uint;
- let b = &global as *const int as uint;
+pub fn verify_same(a: &'static isize) {
+ let a = a as *const isize as usize;
+ let b = &global as *const isize as usize;
assert_eq!(a, b);
}
-pub fn verify_same2(a: &'static int) {
- let a = a as *const int as uint;
- let b = global2 as *const int as uint;
+pub fn verify_same2(a: &'static isize) {
+ let a = a as *const isize as usize;
+ let b = global2 as *const isize as usize;
assert_eq!(a, b);
}
// except according to those terms.
pub struct S {
- pub x: int,
- pub y: int,
+ pub x: isize,
+ pub y: isize,
}
pub type S2 = S;
}
#[derive(Copy)]
-pub struct TupleStruct(pub uint, pub &'static str);
+pub struct TupleStruct(pub usize, pub &'static str);
// used by the cfail test
#[derive(Copy)]
pub struct StructWithFields {
- foo: int,
+ foo: isize,
}
#[derive(Copy)]
pub enum EnumWithVariants {
EnumVariant,
- EnumVariantArg(int)
+ EnumVariantArg(isize)
}
enum request {
get_count,
- bytes(uint),
+ bytes(usize),
stop
}
-fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
+fn server(requests: &Receiver<request>, responses: &Sender<usize>) {
let mut count = 0;
let mut done = false;
while !done {
let (to_parent, from_child) = channel();
let (to_child, from_parent) = channel();
- let size = args[1].parse::<uint>().unwrap();
- let workers = args[2].parse::<uint>().unwrap();
+ let size = args[1].parse::<usize>().unwrap();
+ let workers = args[2].parse::<usize>().unwrap();
let num_bytes = 100;
let mut result = None;
let mut p = Some((to_child, to_parent, from_parent));
enum request {
get_count,
- bytes(uint),
+ bytes(usize),
stop
}
-fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
- let mut count: uint = 0;
+fn server(requests: &Receiver<request>, responses: &Sender<usize>) {
+ let mut count: usize = 0;
let mut done = false;
while !done {
match requests.recv() {
fn run(args: &[String]) {
let (to_parent, from_child) = channel();
- let size = args[1].parse::<uint>().unwrap();
- let workers = args[2].parse::<uint>().unwrap();
+ let size = args[1].parse::<usize>().unwrap();
+ let workers = args[2].parse::<usize>().unwrap();
let num_bytes = 100;
let mut result = None;
let mut to_parent = Some(to_parent);
use std::time::Duration;
// A poor man's pipe.
-type pipe = Arc<(Mutex<Vec<uint>>, Condvar)>;
+type pipe = Arc<(Mutex<Vec<usize>>, Condvar)>;
-fn send(p: &pipe, msg: uint) {
+fn send(p: &pipe, msg: usize) {
let &(ref lock, ref cond) = &**p;
let mut arr = lock.lock().unwrap();
arr.push(msg);
cond.notify_one();
}
-fn recv(p: &pipe) -> uint {
+fn recv(p: &pipe) -> usize {
let &(ref lock, ref cond) = &**p;
let mut arr = lock.lock().unwrap();
while arr.is_empty() {
}
-fn thread_ring(i: uint, count: uint, num_chan: pipe, num_port: pipe) {
+fn thread_ring(i: usize, count: usize, num_chan: pipe, num_port: pipe) {
let mut num_chan = Some(num_chan);
let mut num_port = Some(num_port);
// Send/Receive lots of messages.
args.collect()
};
- let num_tasks = args[1].parse::<uint>().unwrap();
- let msg_per_task = args[2].parse::<uint>().unwrap();
+ let num_tasks = args[1].parse::<usize>().unwrap();
+ let msg_per_task = args[2].parse::<usize>().unwrap();
let (num_chan, num_port) = init();
fn smooth(v: f32) -> f32 { v * v * (3.0 - 2.0 * v) }
fn random_gradient<R: Rng>(r: &mut R) -> Vec2 {
- let v = PI * 2.0 * r.gen();
+ let v = PI * 2.0 * r.gen::<f32>();
Vec2 { x: v.cos(), y: v.sin() }
}
let mut rng = StdRng::new().unwrap();
let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }; 256];
- for x in &mut rgradients[] {
+ for x in &mut rgradients[..] {
*x = random_gradient(&mut rng);
}
}
fn get_gradient(&self, x: i32, y: i32) -> Vec2 {
- let idx = self.permutations[(x & 255) as uint] +
- self.permutations[(y & 255) as uint];
- self.rgradients[(idx & 255) as uint]
+ let idx = self.permutations[(x & 255) as usize] +
+ self.permutations[(y & 255) as usize];
+ self.rgradients[(idx & 255) as usize]
}
fn get_gradients(&self, x: f32, y: f32) -> ([Vec2; 4], [Vec2; 4]) {
for y in 0..256 {
for x in 0..256 {
- let idx = (pixels[y*256+x] / 0.2) as uint;
+ let idx = (pixels[y*256+x] / 0.2) as usize;
print!("{}", symbols[idx]);
}
print!("\n");
#[derive(Copy)]
struct CreatureInfo {
- name: uint,
+ name: usize,
color: Color
}
out
}
-fn show_digit(nn: uint) -> &'static str {
+fn show_digit(nn: usize) -> &'static str {
match nn {
0 => {" zero"}
1 => {" one"}
}
}
-struct Number(uint);
+struct Number(usize);
impl fmt::Debug for Number {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut out = vec![];
}
fn creature(
- name: uint,
+ name: usize,
mut color: Color,
from_rendezvous: Receiver<CreatureInfo>,
to_rendezvous: Sender<CreatureInfo>,
to_rendezvous_log.send(report).unwrap();
}
-fn rendezvous(nn: uint, set: Vec<Color>) {
+fn rendezvous(nn: usize, set: Vec<Color>) {
// these ports will allow us to hear from the creatures
let (to_rendezvous, from_creatures) = channel::<CreatureInfo>();
impl Perm {
fn new(n: u32) -> Perm {
let mut fact = [1; 16];
- for i in 1..n as uint + 1 {
+ for i in 1..n as usize + 1 {
fact[i] = fact[i - 1] * i as u32;
}
Perm {
*place = i as i32 + 1;
}
- for i in (1..self.n as uint).rev() {
+ for i in (1..self.n as usize).rev() {
let d = idx / self.fact[i] as i32;
self.cnt[i] = d;
idx %= self.fact[i] as i32;
*place = (*val) as u8
}
- let d = d as uint;
+ let d = d as usize;
for j in 0..i + 1 {
self.perm.p[j] = if j + d <= i {pp[j + d]} else {pp[j+d-i-1]} as i32;
}
}
fn count(&self) -> u32 { self.permcount }
- fn max(&self) -> u32 { self.fact[self.n as uint] }
+ fn max(&self) -> u32 { self.fact[self.n as usize] }
fn next(&mut self) -> P {
next_permutation(&mut self.perm.p, &mut self.cnt);
}
-fn reverse(tperm: &mut [i32], k: uint) {
+fn reverse(tperm: &mut [i32], k: usize) {
tperm[..k].reverse()
}
-fn work(mut perm: Perm, n: uint, max: uint) -> (i32, i32) {
+fn work(mut perm: Perm, n: usize, max: usize) -> (i32, i32) {
let mut checksum = 0;
let mut maxflips = 0;
let mut flips = 0;
while p.p[0] != 1 {
- let k = p.p[0] as uint;
+ let k = p.p[0] as usize;
reverse(&mut p.p, k);
flips += 1;
}
let max = cmp::min(j+k, perm.max());
futures.push(thread::scoped(move|| {
- work(perm, j as uint, max as uint)
+ work(perm, j as usize, max as usize)
}))
}
let mut buf = repeat(0).take(alu_len + LINE_LEN).collect::<Vec<_>>();
let alu: &[u8] = self.alu.as_bytes();
- copy_memory(&mut buf, alu);
+ copy_memory(alu, &mut buf);
let buf_len = buf.len();
- copy_memory(&mut buf[alu_len..buf_len],
- &alu[..LINE_LEN]);
+ copy_memory(&alu[..LINE_LEN], &mut buf[alu_len..buf_len]);
let mut pos = 0;
let mut bytes;
}
// given a map, print a sorted version of it
-fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> String {
- fn pct(xx: uint, yy: uint) -> f64 {
+fn sort_and_fmt(mm: &HashMap<Vec<u8> , usize>, total: usize) -> String {
+ fn pct(xx: usize, yy: usize) -> f64 {
return (xx as f64) * 100.0 / (yy as f64);
}
}
// given a map, search for the frequency of a pattern
-fn find(mm: &HashMap<Vec<u8> , uint>, key: String) -> uint {
+fn find(mm: &HashMap<Vec<u8> , usize>, key: String) -> usize {
let key = key.into_ascii_lowercase();
match mm.get(key.as_bytes()) {
option::Option::None => { return 0; }
}
// given a map, increment the counter for a key
-fn update_freq(mm: &mut HashMap<Vec<u8> , uint>, key: &[u8]) {
+fn update_freq(mm: &mut HashMap<Vec<u8> , usize>, key: &[u8]) {
let key = key.to_vec();
let newval = match mm.remove(&key) {
Some(v) => v + 1,
// given a Vec<u8>, for each window call a function
// i.e., for "hello" and windows of size four,
// run it("hell") and it("ello"), then return "llo"
-fn windows_with_carry<F>(bb: &[u8], nn: uint, mut it: F) -> Vec<u8> where
+fn windows_with_carry<F>(bb: &[u8], nn: usize, mut it: F) -> Vec<u8> where
F: FnMut(&[u8]),
{
let mut ii = 0;
return bb[len - (nn - 1)..len].to_vec();
}
-fn make_sequence_processor(sz: uint,
+fn make_sequence_processor(sz: usize,
from_parent: &Receiver<Vec<u8>>,
to_parent: &Sender<String>) {
- let mut freqs: HashMap<Vec<u8>, uint> = HashMap::new();
+ let mut freqs: HashMap<Vec<u8>, usize> = HashMap::new();
let mut carry = Vec::new();
- let mut total: uint = 0;
+ let mut total: usize = 0;
let mut line: Vec<u8>;
const PI: f64 = 3.141592653589793;
const SOLAR_MASS: f64 = 4.0 * PI * PI;
const YEAR: f64 = 365.24;
-const N_BODIES: uint = 5;
+const N_BODIES: usize = 5;
static BODIES: [Planet;N_BODIES] = [
// Sun
mass: f64,
}
-fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) {
+fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: isize) {
for _ in 0..steps {
let mut b_slice: &mut [_] = bodies;
loop {
}
}
-fn stress(num_tasks: int) {
+fn stress(num_tasks: isize) {
let mut results = Vec::new();
for i in 0..num_tasks {
results.push(thread::spawn(move|| {
/// Retrieves the complement for `i`.
fn cpl8(&self, i: u8) -> u8 {
- self.table8[i as uint]
+ self.table8[i as usize]
}
/// Retrieves the complement for `i`.
fn cpl16(&self, i: u16) -> u16 {
- self.table16[i as uint]
+ self.table16[i as usize]
}
}
// Reader::read_to_end() with a fast growing policy to limit
// recopies. If MREMAP_RETAIN is implemented in the linux kernel
// and jemalloc use it, this trick will become useless.
- const CHUNK: uint = 64 * 1024;
+ const CHUNK: usize = 64 * 1024;
let mut vec = Vec::with_capacity(CHUNK);
loop {
}
/// Finds the first position at which `b` occurs in `s`.
-fn memchr(h: &[u8], n: u8) -> Option<uint> {
+fn memchr(h: &[u8], n: u8) -> Option<usize> {
use libc::{c_void, c_int, size_t};
let res = unsafe {
libc::memchr(h.as_ptr() as *const c_void, n as c_int, h.len() as size_t)
if res.is_null() {
None
} else {
- Some(res as uint - h.as_ptr() as uint)
+ Some(res as usize - h.as_ptr() as usize)
}
}
}
/// Length of a normal line without the terminating \n.
-const LINE_LEN: uint = 60;
+const LINE_LEN: usize = 60;
/// Compute the reverse complement.
fn reverse_complement(seq: &mut [u8], tables: &Tables) {
let mut i = LINE_LEN;
while i < len {
unsafe {
- copy(seq.as_mut_ptr().offset((i - off + 1) as int),
- seq.as_ptr().offset((i - off) as int), off);
+ copy(seq.as_ptr().offset((i - off) as isize),
+ seq.as_mut_ptr().offset((i - off + 1) as isize), off);
*seq.get_unchecked_mut(i - off) = b'\n';
}
i += LINE_LEN + 1;
unsafe {
let mut left = seq.as_mut_ptr() as *mut u16;
// This is slow if len % 2 != 0 but still faster than bytewise operations.
- let mut right = seq.as_mut_ptr().offset(len as int - 2) as *mut u16;
- let end = left.offset(div as int);
+ let mut right = seq.as_mut_ptr().offset(len as isize - 2) as *mut u16;
+ let end = left.offset(div as isize);
while left != end {
let tmp = tables.cpl16(*left);
*left = tables.cpl16(*right);
println!("{:.9}", answer);
}
-fn spectralnorm(n: uint) -> f64 {
+fn spectralnorm(n: usize) -> f64 {
assert!(n % 2 == 0, "only even lengths are accepted");
let mut u = repeat(1.0).take(n).collect::<Vec<_>>();
let mut v = u.clone();
parallel(out, |start, out| mult(v, out, start, |i, j| A(j, i)));
}
-fn mult<F>(v: &[f64], out: &mut [f64], start: uint, a: F)
- where F: Fn(uint, uint) -> f64 {
+fn mult<F>(v: &[f64], out: &mut [f64], start: usize, a: F)
+ where F: Fn(usize, usize) -> f64 {
for (i, slot) in out.iter_mut().enumerate().map(|(i, s)| (i + start, s)) {
let mut sum = f64x2(0.0, 0.0);
for (j, chunk) in v.chunks(2).enumerate().map(|(j, s)| (2 * j, s)) {
}
}
-fn A(i: uint, j: uint) -> f64 {
+fn A(i: usize, j: usize) -> f64 {
((i + j) * (i + j + 1) / 2 + i + 1) as f64
}
// sub-slice of `v`.
fn parallel<'a,T, F>(v: &mut [T], ref f: F)
where T: Send + Sync + 'a,
- F: Fn(uint, &mut [T]) + Sync + 'a {
+ F: Fn(usize, &mut [T]) + Sync + 'a {
let size = v.len() / os::num_cpus() + 1;
v.chunks_mut(size).enumerate().map(|(i, chunk)| {
thread::scoped(move|| {
run(repeat, depth);
}
-fn run(repeat: int, depth: int) {
+fn run(repeat: isize, depth: isize) {
for _ in 0..repeat {
let dur = Duration::span(|| {
let _ = thread::spawn(move|| {
}
}
-fn recurse_or_panic(depth: int, st: Option<State>) {
+fn recurse_or_panic(depth: isize, st: Option<State>) {
if depth == 0 {
panic!();
} else {
use std::env;
use std::thread;
-fn child_generation(gens_left: uint, tx: Sender<()>) {
+fn child_generation(gens_left: usize, tx: Sender<()>) {
// This used to be O(n^2) in the number of generations that ever existed.
// With this code, only as many generations are alive at a time as tasks
// alive at a time,
// except according to those terms.
#[no_mangle]
-pub fn test(x: &[int]) -> int {
+pub fn test(x: &[isize]) -> isize {
let mut y = 0;
let mut i = 0;
while (i < x.len()) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn foo(x: int) -> int {
+fn foo(x: isize) -> isize {
x * x
}
// except according to those terms.
#[no_mangle]
-pub fn test() -> int {
+pub fn test() -> isize {
5
}
// except according to those terms.
#[no_mangle]
-pub fn test(x: int, y: int) -> int {
+pub fn test(x: isize, y: isize) -> isize {
match x {
1 => y,
2 => y*2,
// except according to those terms.
pub struct Struct {
- field: int
+ field: isize
}
impl Struct {
- fn method(&self, x: int) -> int {
+ fn method(&self, x: isize) -> isize {
self.field + x
}
}
b: &Struct,
c: &Struct,
d: &Struct,
- e: &Struct) -> int {
+ e: &Struct) -> isize {
a.method(b.method(c.method(d.method(e.method(1)))))
}
// except according to those terms.
pub struct Struct {
- field: int
+ field: isize
}
impl Struct {
- fn method(&self) -> int {
+ fn method(&self) -> isize {
self.field
}
}
#[no_mangle]
-pub fn test(s: &Struct) -> int {
+pub fn test(s: &Struct) -> isize {
s.method()
}
// except according to those terms.
pub struct Stuff {
- a: int,
+ a: isize,
b: f64
}
}
#[no_mangle]
-pub fn test(t: &Trait) -> int {
+pub fn test(t: &Trait) -> isize {
t.method().a
}
// except according to those terms.
pub trait Trait {
- fn method(&self) -> int;
+ fn method(&self) -> isize;
}
#[no_mangle]
-pub fn test(t: &Trait) -> int {
+pub fn test(t: &Trait) -> isize {
t.method()
}
fn main() {
let mut a = Foo;
let ref b = Foo;
- a += *b; //~ Error: binary assignment operation `+=` cannot be applied to type `Foo`
+ a += *b; //~ Error: binary assignment operation `+=` cannot be applied to types `Foo` and `Foo`
}
fn ice<A>(a: A) {
let r = loop {};
r = r + a;
- //~^ ERROR binary operation `+` cannot be applied to type `A`
+ //~^ ERROR not implemented
+ //~| ERROR not implemented
}
+++ /dev/null
-// 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 "" as foo; //~ ERROR: crate name must not be empty
-//~^ WARNING: obsolete syntax
-
-fn main() {}
+++ /dev/null
-// 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 "#a" as bar; //~ ERROR: invalid character `#` in crate name: `#a`
-//~^ WARNING: obsolete syntax
-
-fn main() {}
+++ /dev/null
-// 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.
-
-fn foo() -> ! { panic!("quux"); }
-fn main() {
- foo() //~ ERROR the type of this value must be known in this context
- ==
- foo();
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:`||` cannot be applied to type `f32`
-
fn main() { let x = 1.0_f32 || 2.0_f32; }
+//~^ ERROR mismatched types
+//~| ERROR mismatched types
+
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:`&&` cannot be applied to type `_`
-
fn main() { let x = 1 && 2; }
+//~^ ERROR mismatched types
+//~| ERROR mismatched types
// except according to those terms.
// This tests that we can't modify Box<&mut T> contents while they
-// are borrowed.
+// are borrowed (#14498).
+//
+// Also includes tests of the errors reported when the Box in question
+// is immutable (#14270).
#![feature(box_syntax)]
struct A { a: isize }
struct B<'a> { a: Box<&'a mut isize> }
+fn indirect_write_to_imm_box() {
+ let mut x: isize = 1;
+ let y: Box<_> = box &mut x;
+ let p = &y;
+ ***p = 2; //~ ERROR cannot assign to data in an immutable container
+ drop(p);
+}
+
fn borrow_in_var_from_var() {
+ let mut x: isize = 1;
+ let mut y: Box<_> = box &mut x;
+ let p = &y;
+ let q = &***p;
+ **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
+ drop(p);
+ drop(q);
+}
+
+fn borrow_in_var_from_var_via_imm_box() {
let mut x: isize = 1;
let y: Box<_> = box &mut x;
let p = &y;
let q = &***p;
**y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
+ //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
fn borrow_in_var_from_field() {
+ let mut x = A { a: 1 };
+ let mut y: Box<_> = box &mut x.a;
+ let p = &y;
+ let q = &***p;
+ **y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
+ drop(p);
+ drop(q);
+}
+
+fn borrow_in_var_from_field_via_imm_box() {
let mut x = A { a: 1 };
let y: Box<_> = box &mut x.a;
let p = &y;
let q = &***p;
**y = 2; //~ ERROR cannot assign to `**y` because it is borrowed
+ //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
fn borrow_in_field_from_var() {
+ let mut x: isize = 1;
+ let mut y = B { a: box &mut x };
+ let p = &y.a;
+ let q = &***p;
+ **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
+ drop(p);
+ drop(q);
+}
+
+fn borrow_in_field_from_var_via_imm_box() {
let mut x: isize = 1;
let y = B { a: box &mut x };
let p = &y.a;
let q = &***p;
**y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
+ //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
fn borrow_in_field_from_field() {
+ let mut x = A { a: 1 };
+ let mut y = B { a: box &mut x.a };
+ let p = &y.a;
+ let q = &***p;
+ **y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
+ drop(p);
+ drop(q);
+}
+
+fn borrow_in_field_from_field_via_imm_box() {
let mut x = A { a: 1 };
let y = B { a: box &mut x.a };
let p = &y.a;
let q = &***p;
**y.a = 2; //~ ERROR cannot assign to `**y.a` because it is borrowed
+ //~^ ERROR cannot assign to data in an immutable container
drop(p);
drop(q);
}
fn main() {
+ indirect_write_to_imm_box();
borrow_in_var_from_var();
+ borrow_in_var_from_var_via_imm_box();
borrow_in_var_from_field();
+ borrow_in_var_from_field_via_imm_box();
borrow_in_field_from_var();
+ borrow_in_field_from_var_via_imm_box();
borrow_in_field_from_field();
+ borrow_in_field_from_field_via_imm_box();
}
// Test that immutable pattern bindings cannot be reassigned.
+#![feature(slice_patterns)]
+
enum E {
Foo(isize)
}
// Test that we do not permit moves from &[] matched by a vec pattern.
+#![feature(slice_patterns)]
+
#[derive(Clone, Debug)]
struct Foo {
string: String
y: isize,
}
-#[cfg(stage0)]
-impl Index<String> for Foo {
- type Output = isize;
-
- fn index<'a>(&'a self, z: &String) -> &'a isize {
- if *z == "x" {
- &self.x
- } else {
- &self.y
- }
- }
-}
-
impl<'a> Index<&'a String> for Foo {
type Output = isize;
// except according to those terms.
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
fn a<'a>() -> &'a [isize] {
let vec = vec!(1, 2, 3, 4);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn a() {
let mut v = vec!(1, 2, 3);
let vb: &mut [isize] = &mut v;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
let mut a = [1, 2, 3, 4];
let t = match a {
#![feature(advanced_slice_patterns)]
#![feature(box_patterns)]
#![feature(box_syntax)]
+#![feature(slice_patterns)]
fn a() {
let mut vec = [box 1, box 2, box 3];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn a<'a>() -> &'a isize {
let vec = vec!(1, 2, 3, 4);
let vec: &[isize] = &vec; //~ ERROR `vec` does not live long enough
+++ /dev/null
-// 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(custom_attribute)]
-
-#[phase(blah)]
-//~^ ERROR #[phase] is deprecated
-extern crate foo;
-
-fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
let x = [ 1, 2, 3, 4, 5 ];
match x {
+++ /dev/null
-// Copyright 2015 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.
-
-#![allow(dead_code, unused_variables)]
-#![feature(rustc_attrs)]
-
-mod u {
- type X = uint; //~ WARN the `uint` type is deprecated
- struct Foo {
- x: uint //~ WARN the `uint` type is deprecated
- }
- fn bar(x: uint) { //~ WARN the `uint` type is deprecated
- 1_u; //~ WARN the `u` and `us` suffixes on integers are deprecated
- 1_us; //~ WARN the `u` and `us` suffixes on integers are deprecated
- }
-}
-mod i {
- type X = int; //~ WARN the `int` type is deprecated
- struct Foo {
- x: int //~ WARN the `int` type is deprecated
- }
- fn bar(x: int) { //~ WARN the `int` type is deprecated
- 1_i; //~ WARN the `i` and `is` suffixes on integers are deprecated
- 1_is; //~ WARN the `i` and `is` suffixes on integers are deprecated
- }
-}
-
-#[rustc_error]
-fn main() { //~ ERROR compilation successful
-}
fn g() { }
let x = f == g;
//~^ ERROR binary operation `==` cannot be applied
+ //~| ERROR mismatched types
}
// Test that `#[unsafe_destructor]` attribute is gated by `unsafe_destructor`
// feature gate.
+//
+// (This test can be removed entirely when we remove the
+// `unsafe_destructor` feature itself.)
struct D<'a>(&'a u32);
#[unsafe_destructor]
+//~^ ERROR `#[unsafe_destructor]` does nothing anymore
+//~| HELP: add #![feature(unsafe_destructor)] to the crate attributes to enable
+// (but of couse there is no point in doing so)
impl<'a> Drop for D<'a> {
- //~^ ERROR `#[unsafe_destructor]` allows too many unsafe patterns
fn drop(&mut self) { }
}
-//~^ HELP: add #![feature(unsafe_destructor)] to the crate attributes to enable
pub fn main() { }
fn main() {
let x = ();
1 +
- x //~ ERROR mismatched types
- //~| expected `_`
- //~| found `()`
- //~| expected integral variable
- //~| found ()
+ x //~^ ERROR E0277
+ //~| ERROR E0277
;
let x: () = ();
1 +
- x //~ ERROR mismatched types
- //~| expected `_`
- //~| found `()`
- //~| expected integral variable
- //~| found ()
+ x //~^ ERROR E0277
+ //~| ERROR E0277
;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
let sl = vec![1,2,3];
let v: isize = match &*sl {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) {
match (l1, l2) {
([], []) => println!("both empty"),
--- /dev/null
+// 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.
+
+// pretty-expanded FIXME #23616
+
+#![feature(std_misc, libc)]
+
+extern crate libc;
+
+use std::thunk::Thunk;
+
+fn foo(_: Thunk) {}
+
+fn main() {
+ foo(loop {
+ unsafe { libc::exit(0 as libc::c_int); }
+ });
+ 2_usize + (loop {});
+ //~^ ERROR E0277
+ //~| ERROR E0277
+}
// compile-flags:-Z verbose
+#![feature(slice_patterns)]
+
fn main() {
let x = [1,2];
let y = match x {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
let x = [1,2];
let y = match x {
+++ /dev/null
-// 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.
-
-#![crate_type = "lib"]
-
-use std::marker::PhantomData;
-
-enum NodeContents<'a> {
- Children(Vec<Node<'a>>),
-}
-
-impl<'a> Drop for NodeContents<'a> {
- //~^ ERROR cannot implement a destructor on a structure with type parameters
- fn drop( &mut self ) {
- }
-}
-
-struct Node<'a> {
- contents: NodeContents<'a>,
- marker: PhantomData<&'a ()>,
-}
-
-impl<'a> Node<'a> {
- fn noName(contents: NodeContents<'a>) -> Node<'a> {
- Node { contents: contents, marker: PhantomData }
- }
-}
-
-fn main() {}
+++ /dev/null
-// 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.
-
-struct AutoBuilder<'a> {
- context: &'a isize
-}
-
-impl<'a> Drop for AutoBuilder<'a> {
- //~^ ERROR cannot implement a destructor on a structure with type parameters
- fn drop(&mut self) {
- }
-}
-
-fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
let values: Vec<u8> = vec![1,2,3,4,5,6,7,8];
+++ /dev/null
-// 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.
-
-// Used to cause an ICE
-
-struct Foo<T>{
- x : T
-}
-
-type FooInt = Foo<isize>;
-
-impl Drop for FooInt {
-//~^ ERROR cannot implement a destructor on a structure with type parameters
- fn drop(&mut self){}
-}
-
-fn main() {}
trait Sized : PhantomFn<Self> {}
#[start]
-fn main(_: int, _: *const *const u8) -> int {
+fn main(_: isize, _: *const *const u8) -> isize {
0
}
fn bind<B, F>(&self, mut f: F) where F: FnMut(A) -> Vec<B> {
let mut r = panic!();
for elt in self { r = r + f(*elt); }
- //~^ ERROR binary operation `+` cannot be applied to type `collections::vec::Vec<B>`
+ //~^ ERROR E0277
+ //~| ERROR E0277
}
}
fn main() {
fn main() {
let x = |ref x: isize| -> isize { x += 1; };
- //~^ ERROR binary assignment operation `+=` cannot be applied to type `&isize`
+ //~^ ERROR E0368
}
// except according to those terms.
#![feature(rustc_attrs)]
+#![feature(slice_patterns)]
#![allow(dead_code)]
// Matching against NaN should result in a warning
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Verify that single-variant enums cant be de-referenced
+// Verify that single-variant enums can't be de-referenced
// Regression test for issue #9814
enum Foo { Bar(isize) }
+++ /dev/null
-// 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.
-
-
-struct Bar<'a> {
- f: &'a isize,
-}
-
-impl<'a> Drop for Bar<'a> {
-//~^ ERROR E0141
- fn drop(&mut self) {
- }
-}
-
-struct Baz {
- f: &'static isize,
-}
-
-impl Drop for Baz {
- fn drop(&mut self) {
- }
-}
-
-fn main() { }
extern crate libc;
-use std::num::Int;
-
struct Foo {
x: usize,
b: bool, //~ ERROR: struct field is never used
}
fn quy() {
- let i = -23_usize; //~ WARNING negation of unsigned int literal may be unintentional
+ let i = -23_us; //~ WARNING negation of unsigned int literal may be unintentional
//~^ WARNING unused variable
}
fn quz() {
- let i = 23_usize;
+ let i = 23_us;
let j = -i; //~ WARNING negation of unsigned int variable may be unintentional
//~^ WARNING unused variable
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-l :static
+// compile-flags:-l static=
// error-pattern: empty library name given via `-l`
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-l foo:bar
+// compile-flags:-l bar=foo
// error-pattern: unknown library kind `bar`, expected one of dylib, framework, or static
fn main() {
// ignore-macos
// ignore-ios
-// compile-flags:-l foo:framework
+// compile-flags:-l framework=foo
// error-pattern: native frameworks are only available on OSX targets
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
// The arity of `ref x` is always 1. If the pattern is compared to some non-structural type whose
// arity is always 0, an ICE occurs.
//
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn a() {
let v = [1, 2, 3];
match v {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
match () {
[()] => { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn main() {
match "foo".to_string() {
['f', 'o', ..] => {} //~ ERROR mismatched types
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
fn main() {
let x: Vec<(isize, isize)> = Vec::new();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
enum t { a(u), b }
enum u { c, d }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
enum t { a, b, }
fn main() {
// except according to those terms.
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
struct Foo {
first: bool,
+++ /dev/null
-// Copyright 2015 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(plugin)]
-
-#[plugin] //~ ERROR #[plugin] on `extern crate` is deprecated
-//~^ HELP use a crate attribute instead, i.e. #![plugin(std)]
-extern crate std;
-
-fn main() {}
let _ = 0u32..10i32;
//~^ ERROR start and end of range have incompatible types
- // Float => does not implement iterator.
- for i in 0f32..42f32 {}
- //~^ ERROR the trait `core::num::Int` is not implemented for the type `f32`
+ // Bool => does not implement iterator.
+ for i in false..true {}
+ //~^ ERROR the trait
+ //~^^ ERROR the trait
// Unsized type.
let arr: &[_] = &[1, 2, 3];
--- /dev/null
+// Copyright 2015 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.
+
+// Test that types that appear in assoc bindings in an object
+// type are subject to the reflect check.
+
+use std::marker::Reflect;
+use std::io::Write;
+
+trait Get {
+ type Output;
+ fn get(self) -> Self::Output;
+}
+
+struct Struct<T>(T);
+
+fn is_reflect<T:Reflect>() { }
+
+fn a<T>() {
+ is_reflect::<Box<Get<Output=T>>>(); //~ ERROR not implemented
+}
+
+fn ok_a<T: Reflect>() {
+ is_reflect::<Box<Get<Output=T>>>(); // OK
+}
+
+fn main() {
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Test that types that appear in input types in an object type are
+// subject to the reflect check.
+
+use std::marker::Reflect;
+use std::io::Write;
+
+trait Get<T> {
+ fn get(self) -> T;
+}
+
+struct Struct<T>(T);
+
+fn is_reflect<T:Reflect>() { }
+
+fn a<T>() {
+ is_reflect::<T>(); //~ ERROR not implemented
+}
+
+fn ok_a<T: Reflect>() {
+ is_reflect::<T>(); // OK
+}
+
+fn b<T>() {
+ is_reflect::<Box<Get<T>>>(); //~ ERROR not implemented
+}
+
+fn ok_b<T: Reflect>() {
+ is_reflect::<Box<Get<T>>>(); // OK
+}
+
+fn c<T>() {
+ is_reflect::<Box<Get<Struct<T>>>>(); //~ ERROR not implemented
+}
+
+fn main() {
+ is_reflect::<Box<Get<Struct<()>>>>(); // OK
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Test that there is no way to get a generic type `T` to be
+// considered as `Reflect` (or accessible via something that is
+// considered `Reflect`) without a reflect bound, but that any
+// concrete type works fine. Note that object types are tested
+// separately.
+
+use std::marker::Reflect;
+use std::io::Write;
+
+struct Struct<T>(T);
+
+fn is_reflect<T:Reflect>() { }
+
+fn c<T>() {
+ is_reflect::<Struct<T>>(); //~ ERROR not implemented
+}
+
+fn ok_c<T: Reflect>() {
+ is_reflect::<Struct<T>>(); // OK
+}
+
+fn d<T>() {
+ is_reflect::<(i32, T)>(); //~ ERROR not implemented
+}
+
+fn main() {
+ is_reflect::<&i32>(); // OK
+ is_reflect::<Box<Write>>(); // OK
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
fn assert_static<T: 'static>(_t: T) {}
fn main() {
fn foo(p: &Panolpy) {
22 >> p.char;
- //~^ ERROR right-hand-side of a shift operation must have integral type
+ //~^ ERROR E0277
+ //~| ERROR E0277
22 >> p.str;
- //~^ ERROR right-hand-side of a shift operation must have integral type
+ //~^ ERROR E0277
+ //~| ERROR E0277
22 >> p;
- //~^ ERROR right-hand-side of a shift operation must have integral type
+ //~^ ERROR E0277
+ //~| ERROR E0277
- // We could be more accepting in the case of a type not yet inferred, but not
- // known to be an integer, but meh.
let x;
- 22 >> x;
- //~^ ERROR the type of this value must be known in this context
+ 22 >> x; // ambiguity error winds up being suppressed
22 >> 1;
// Integer literal types are OK
// ignore-tidy-linelength
+#![feature(core)]
use std::simd::f32x4;
+++ /dev/null
-// 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.
-
-// Test slicing &expr[] is deprecated and gives a helpful error message.
-
-struct Foo;
-
-fn main() {
- let x = Foo;
- &x[];
- //~^ WARN obsolete syntax
- //~| ERROR cannot index
-}
+++ /dev/null
-// 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.
-
-
-
-// Regression test for issue #15557
-
-#![allow(dead_code)]
-struct AReg1<'a>(&'a u32);
-
-impl<'a> Drop for AReg1<'a> {
-//~^ ERROR: cannot implement a destructor on a structure with type parameters
- fn drop(&mut self) {}
-}
-
-fn main() {}
// error-pattern:can't find crate for `extra`
-extern crate "fake-crate" as extra;
+extern crate fake_crate as extra;
fn main() { }
--- /dev/null
+// 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.
+
+// Check that `T:'a` is contravariant in T.
+
+#![feature(rustc_attrs)]
+
+#[rustc_variance]
+trait Foo: 'static { //~ ERROR types=[[];[-];[]]
+}
+
+#[rustc_variance]
+trait Bar<T> { //~ ERROR types=[[+];[-];[]]
+ fn do_it(&self)
+ where T: 'static;
+}
+
+fn main() { }
#![no_std]
extern crate core;
-extern crate "weak-lang-items" as other;
+extern crate weak_lang_items;
// compile-flags:-g
// gdb-command:run
-// gdb-command:whatis 'basic-types-globals-metadata::B'
+// gdb-command:whatis 'basic_types_globals_metadata::B'
// gdb-check:type = bool
-// gdb-command:whatis 'basic-types-globals-metadata::I'
+// gdb-command:whatis 'basic_types_globals_metadata::I'
// gdb-check:type = isize
-// gdb-command:whatis 'basic-types-globals-metadata::C'
+// gdb-command:whatis 'basic_types_globals_metadata::C'
// gdb-check:type = char
-// gdb-command:whatis 'basic-types-globals-metadata::I8'
+// gdb-command:whatis 'basic_types_globals_metadata::I8'
// gdb-check:type = i8
-// gdb-command:whatis 'basic-types-globals-metadata::I16'
+// gdb-command:whatis 'basic_types_globals_metadata::I16'
// gdb-check:type = i16
-// gdb-command:whatis 'basic-types-globals-metadata::I32'
+// gdb-command:whatis 'basic_types_globals_metadata::I32'
// gdb-check:type = i32
-// gdb-command:whatis 'basic-types-globals-metadata::I64'
+// gdb-command:whatis 'basic_types_globals_metadata::I64'
// gdb-check:type = i64
-// gdb-command:whatis 'basic-types-globals-metadata::U'
+// gdb-command:whatis 'basic_types_globals_metadata::U'
// gdb-check:type = usize
-// gdb-command:whatis 'basic-types-globals-metadata::U8'
+// gdb-command:whatis 'basic_types_globals_metadata::U8'
// gdb-check:type = u8
-// gdb-command:whatis 'basic-types-globals-metadata::U16'
+// gdb-command:whatis 'basic_types_globals_metadata::U16'
// gdb-check:type = u16
-// gdb-command:whatis 'basic-types-globals-metadata::U32'
+// gdb-command:whatis 'basic_types_globals_metadata::U32'
// gdb-check:type = u32
-// gdb-command:whatis 'basic-types-globals-metadata::U64'
+// gdb-command:whatis 'basic_types_globals_metadata::U64'
// gdb-check:type = u64
-// gdb-command:whatis 'basic-types-globals-metadata::F32'
+// gdb-command:whatis 'basic_types_globals_metadata::F32'
// gdb-check:type = f32
-// gdb-command:whatis 'basic-types-globals-metadata::F64'
+// gdb-command:whatis 'basic_types_globals_metadata::F64'
// gdb-check:type = f64
// gdb-command:continue
// N.B. These are `mut` only so they don't constant fold away.
static mut B: bool = false;
-static mut I: int = -1;
+static mut I: isize = -1;
static mut C: char = 'a';
static mut I8: i8 = 68;
static mut I16: i16 = -16;
static mut I32: i32 = -32;
static mut I64: i64 = -64;
-static mut U: uint = 1;
+static mut U: usize = 1;
static mut U8: u8 = 100;
static mut U16: u16 = 16;
static mut U32: u32 = 32;
// compile-flags:-g
// gdb-command:run
-// gdb-command:print 'basic-types-globals::B'
+// gdb-command:print 'basic_types_globals::B'
// gdb-check:$1 = false
-// gdb-command:print 'basic-types-globals::I'
+// gdb-command:print 'basic_types_globals::I'
// gdb-check:$2 = -1
-// gdb-command:print 'basic-types-globals::C'
+// gdb-command:print 'basic_types_globals::C'
// gdb-check:$3 = 97
-// gdb-command:print/d 'basic-types-globals::I8'
+// gdb-command:print/d 'basic_types_globals::I8'
// gdb-check:$4 = 68
-// gdb-command:print 'basic-types-globals::I16'
+// gdb-command:print 'basic_types_globals::I16'
// gdb-check:$5 = -16
-// gdb-command:print 'basic-types-globals::I32'
+// gdb-command:print 'basic_types_globals::I32'
// gdb-check:$6 = -32
-// gdb-command:print 'basic-types-globals::I64'
+// gdb-command:print 'basic_types_globals::I64'
// gdb-check:$7 = -64
-// gdb-command:print 'basic-types-globals::U'
+// gdb-command:print 'basic_types_globals::U'
// gdb-check:$8 = 1
-// gdb-command:print/d 'basic-types-globals::U8'
+// gdb-command:print/d 'basic_types_globals::U8'
// gdb-check:$9 = 100
-// gdb-command:print 'basic-types-globals::U16'
+// gdb-command:print 'basic_types_globals::U16'
// gdb-check:$10 = 16
-// gdb-command:print 'basic-types-globals::U32'
+// gdb-command:print 'basic_types_globals::U32'
// gdb-check:$11 = 32
-// gdb-command:print 'basic-types-globals::U64'
+// gdb-command:print 'basic_types_globals::U64'
// gdb-check:$12 = 64
-// gdb-command:print 'basic-types-globals::F32'
+// gdb-command:print 'basic_types_globals::F32'
// gdb-check:$13 = 2.5
-// gdb-command:print 'basic-types-globals::F64'
+// gdb-command:print 'basic_types_globals::F64'
// gdb-check:$14 = 3.5
// gdb-command:continue
// N.B. These are `mut` only so they don't constant fold away.
static mut B: bool = false;
-static mut I: int = -1;
+static mut I: isize = -1;
static mut C: char = 'a';
static mut I8: i8 = 68;
static mut I16: i16 = -16;
static mut I32: i32 = -32;
static mut I64: i64 = -64;
-static mut U: uint = 1;
+static mut U: usize = 1;
static mut U8: u8 = 100;
static mut U16: u16 = 16;
static mut U32: u32 = 32;
// gdb-command:run
// Check initializers
-// gdb-command:print 'basic-types-mut-globals::B'
+// gdb-command:print 'basic_types_mut_globals::B'
// gdb-check:$1 = false
-// gdb-command:print 'basic-types-mut-globals::I'
+// gdb-command:print 'basic_types_mut_globals::I'
// gdb-check:$2 = -1
-// gdb-command:print 'basic-types-mut-globals::C'
+// gdb-command:print 'basic_types_mut_globals::C'
// gdb-check:$3 = 97
-// gdb-command:print/d 'basic-types-mut-globals::I8'
+// gdb-command:print/d 'basic_types_mut_globals::I8'
// gdb-check:$4 = 68
-// gdb-command:print 'basic-types-mut-globals::I16'
+// gdb-command:print 'basic_types_mut_globals::I16'
// gdb-check:$5 = -16
-// gdb-command:print 'basic-types-mut-globals::I32'
+// gdb-command:print 'basic_types_mut_globals::I32'
// gdb-check:$6 = -32
-// gdb-command:print 'basic-types-mut-globals::I64'
+// gdb-command:print 'basic_types_mut_globals::I64'
// gdb-check:$7 = -64
-// gdb-command:print 'basic-types-mut-globals::U'
+// gdb-command:print 'basic_types_mut_globals::U'
// gdb-check:$8 = 1
-// gdb-command:print/d 'basic-types-mut-globals::U8'
+// gdb-command:print/d 'basic_types_mut_globals::U8'
// gdb-check:$9 = 100
-// gdb-command:print 'basic-types-mut-globals::U16'
+// gdb-command:print 'basic_types_mut_globals::U16'
// gdb-check:$10 = 16
-// gdb-command:print 'basic-types-mut-globals::U32'
+// gdb-command:print 'basic_types_mut_globals::U32'
// gdb-check:$11 = 32
-// gdb-command:print 'basic-types-mut-globals::U64'
+// gdb-command:print 'basic_types_mut_globals::U64'
// gdb-check:$12 = 64
-// gdb-command:print 'basic-types-mut-globals::F32'
+// gdb-command:print 'basic_types_mut_globals::F32'
// gdb-check:$13 = 2.5
-// gdb-command:print 'basic-types-mut-globals::F64'
+// gdb-command:print 'basic_types_mut_globals::F64'
// gdb-check:$14 = 3.5
// gdb-command:continue
// Check new values
-// gdb-command:print 'basic-types-mut-globals'::B
+// gdb-command:print 'basic_types_mut_globals'::B
// gdb-check:$15 = true
-// gdb-command:print 'basic-types-mut-globals'::I
+// gdb-command:print 'basic_types_mut_globals'::I
// gdb-check:$16 = 2
-// gdb-command:print 'basic-types-mut-globals'::C
+// gdb-command:print 'basic_types_mut_globals'::C
// gdb-check:$17 = 102
-// gdb-command:print/d 'basic-types-mut-globals'::I8
+// gdb-command:print/d 'basic_types_mut_globals'::I8
// gdb-check:$18 = 78
-// gdb-command:print 'basic-types-mut-globals'::I16
+// gdb-command:print 'basic_types_mut_globals'::I16
// gdb-check:$19 = -26
-// gdb-command:print 'basic-types-mut-globals'::I32
+// gdb-command:print 'basic_types_mut_globals'::I32
// gdb-check:$20 = -12
-// gdb-command:print 'basic-types-mut-globals'::I64
+// gdb-command:print 'basic_types_mut_globals'::I64
// gdb-check:$21 = -54
-// gdb-command:print 'basic-types-mut-globals'::U
+// gdb-command:print 'basic_types_mut_globals'::U
// gdb-check:$22 = 5
-// gdb-command:print/d 'basic-types-mut-globals'::U8
+// gdb-command:print/d 'basic_types_mut_globals'::U8
// gdb-check:$23 = 20
-// gdb-command:print 'basic-types-mut-globals'::U16
+// gdb-command:print 'basic_types_mut_globals'::U16
// gdb-check:$24 = 32
-// gdb-command:print 'basic-types-mut-globals'::U32
+// gdb-command:print 'basic_types_mut_globals'::U32
// gdb-check:$25 = 16
-// gdb-command:print 'basic-types-mut-globals'::U64
+// gdb-command:print 'basic_types_mut_globals'::U64
// gdb-check:$26 = 128
-// gdb-command:print 'basic-types-mut-globals'::F32
+// gdb-command:print 'basic_types_mut_globals'::F32
// gdb-check:$27 = 5.75
-// gdb-command:print 'basic-types-mut-globals'::F64
+// gdb-command:print 'basic_types_mut_globals'::F64
// gdb-check:$28 = 9.25
#![allow(unused_variables)]
#![omit_gdb_pretty_printer_section]
static mut B: bool = false;
-static mut I: int = -1;
+static mut I: isize = -1;
static mut C: char = 'a';
static mut I8: i8 = 68;
static mut I16: i16 = -16;
static mut I32: i32 = -32;
static mut I64: i64 = -64;
-static mut U: uint = 1;
+static mut U: usize = 1;
static mut U8: u8 = 100;
static mut U16: u16 = 16;
static mut U32: u32 = 32;
// lldb-check:[...]$1 = -1
// NOTE: LLDB does not support 32bit chars
-// d ebugger:print (uint)(c)
+// d ebugger:print (usize)(c)
// c heck:$3 = 97
// lldb-command:print i8
fn main() {
let b: bool = false;
- let i: int = -1;
+ let i: isize = -1;
let c: char = 'a';
let i8: i8 = 68;
let i16: i16 = -16;
let i32: i32 = -32;
let i64: i64 = -64;
- let u: uint = 1;
+ let u: usize = 1;
let u8: u8 = 100;
let u16: u16 = 16;
let u32: u32 = 32;
let bool_val: bool = true;
let bool_ref: &bool = &bool_val;
- let int_val: int = -1;
- let int_ref: &int = &int_val;
+ let int_val: isize = -1;
+ let int_ref: &isize = &int_val;
let char_val: char = 'a';
let char_ref: &char = &char_val;
let i64_val: i64 = -64;
let i64_ref: &i64 = &i64_val;
- let uint_val: uint = 1;
- let uint_ref: &uint = &uint_val;
+ let uint_val: usize = 1;
+ let uint_ref: &usize = &uint_val;
let u8_val: u8 = 100;
let u8_ref: &u8 = &u8_val;
#![omit_gdb_pretty_printer_section]
struct SomeStruct {
- x: int,
+ x: isize,
y: f64
}
fn main() {
let stack_val: SomeStruct = SomeStruct { x: 10, y: 23.5 };
let stack_val_ref: &SomeStruct = &stack_val;
- let stack_val_interior_ref_1: &int = &stack_val.x;
+ let stack_val_interior_ref_1: &isize = &stack_val.x;
let stack_val_interior_ref_2: &f64 = &stack_val.y;
let ref_to_unnamed: &SomeStruct = &SomeStruct { x: 11, y: 24.5 };
let unique_val: Box<_> = box SomeStruct { x: 13, y: 26.5 };
let unique_val_ref: &SomeStruct = &*unique_val;
- let unique_val_interior_ref_1: &int = &unique_val.x;
+ let unique_val_interior_ref_1: &isize = &unique_val.x;
let unique_val_interior_ref_2: &f64 = &unique_val.y;
zzz(); // #break
let bool_box: Box<bool> = box true;
let bool_ref: &bool = &*bool_box;
- let int_box: Box<int> = box -1;
- let int_ref: &int = &*int_box;
+ let int_box: Box<isize> = box -1;
+ let int_ref: &isize = &*int_box;
let char_box: Box<char> = box 'a';
let char_ref: &char = &*char_box;
let i64_box: Box<i64> = box -64;
let i64_ref: &i64 = &*i64_box;
- let uint_box: Box<uint> = box 1;
- let uint_ref: &uint = &*uint_box;
+ let uint_box: Box<usize> = box 1;
+ let uint_ref: &usize = &*uint_box;
let u8_box: Box<u8> = box 100;
let u8_ref: &u8 = &*u8_box;
#[derive(Clone)]
struct Struct {
- a: int,
+ a: isize,
b: f64
}
zzz(); // #break
}
-fn tup(a: (int, uint, f64, f64)) {
+fn tup(a: (isize, usize, f64, f64)) {
zzz(); // #break
}
-struct Newtype(f64, f64, int, uint);
+struct Newtype(f64, f64, isize, usize);
fn new_type(a: Newtype) {
zzz(); // #break
fn method(self) -> Self;
}
-impl Trait for int {
- fn method(self) -> int {
+impl Trait for isize {
+ fn method(self) -> isize {
zzz(); // #break
self
}
}
struct Struct {
- x: uint,
- y: uint,
+ x: usize,
+ y: usize,
}
impl Trait for Struct {
}
}
-impl Trait for (f64, int, int, f64) {
- fn method(self) -> (f64, int, int, f64) {
+impl Trait for (f64, isize, isize, f64) {
+ fn method(self) -> (f64, isize, isize, f64) {
zzz(); // #break
self
}
}
fn main() {
- let _ = (1111 as int).method();
+ let _ = (1111 as isize).method();
let _ = Struct { x: 2222, y: 3333 }.method();
let _ = (4444.5, 5555, 6666, 7777.5).method();
}
// === GDB TESTS ===================================================================================
-// gdb-command:print 'c-style-enum::SINGLE_VARIANT'
+// gdb-command:print 'c_style_enum::SINGLE_VARIANT'
// gdb-check:$1 = TheOnlyVariant
-// gdb-command:print 'c-style-enum::AUTO_ONE'
+// gdb-command:print 'c_style_enum::AUTO_ONE'
// gdb-check:$2 = One
-// gdb-command:print 'c-style-enum::AUTO_TWO'
+// gdb-command:print 'c_style_enum::AUTO_TWO'
// gdb-check:$3 = One
-// gdb-command:print 'c-style-enum::AUTO_THREE'
+// gdb-command:print 'c_style_enum::AUTO_THREE'
// gdb-check:$4 = One
-// gdb-command:print 'c-style-enum::MANUAL_ONE'
+// gdb-command:print 'c_style_enum::MANUAL_ONE'
// gdb-check:$5 = OneHundred
-// gdb-command:print 'c-style-enum::MANUAL_TWO'
+// gdb-command:print 'c_style_enum::MANUAL_TWO'
// gdb-check:$6 = OneHundred
-// gdb-command:print 'c-style-enum::MANUAL_THREE'
+// gdb-command:print 'c_style_enum::MANUAL_THREE'
// gdb-check:$7 = OneHundred
// gdb-command:run
// gdb-command:print single_variant
// gdb-check:$14 = TheOnlyVariant
-// gdb-command:print 'c-style-enum::AUTO_TWO'
+// gdb-command:print 'c_style_enum::AUTO_TWO'
// gdb-check:$15 = Two
-// gdb-command:print 'c-style-enum::AUTO_THREE'
+// gdb-command:print 'c_style_enum::AUTO_THREE'
// gdb-check:$16 = Three
-// gdb-command:print 'c-style-enum::MANUAL_TWO'
+// gdb-command:print 'c_style_enum::MANUAL_TWO'
// gdb-check:$17 = OneThousand
-// gdb-command:print 'c-style-enum::MANUAL_THREE'
+// gdb-command:print 'c_style_enum::MANUAL_THREE'
// gdb-check:$18 = OneMillion
Unit(i32)
}
-struct TupleStruct (f64, int);
+struct TupleStruct (f64, isize);
-fn simple_tuple((a, b): (int, bool)) {
+fn simple_tuple((a, b): (isize, bool)) {
zzz(); // #break
}
-fn nested_tuple((a, (b, c)): (int, (u16, u16))) {
+fn nested_tuple((a, (b, c)): (isize, (u16, u16))) {
zzz(); // #break
}
-fn destructure_only_first_level((a, b): (int, (u32, u32))) {
+fn destructure_only_first_level((a, b): (isize, (u32, u32))) {
zzz(); // #break
}
zzz(); // #break
}
-fn ignored_tuple_element((m, _, n): (int, u16, i32)) {
+fn ignored_tuple_element((m, _, n): (isize, u16, i32)) {
zzz(); // #break
}
zzz(); // #break
}
-fn managed_box(&aa: &(int, int)) {
+fn managed_box(&aa: &(isize, isize)) {
zzz(); // #break
}
-fn borrowed_pointer(&bb: &(int, int)) {
+fn borrowed_pointer(&bb: &(isize, isize)) {
zzz(); // #break
}
-fn contained_borrowed_pointer((&cc, _): (&int, int)) {
+fn contained_borrowed_pointer((&cc, _): (&isize, isize)) {
zzz(); // #break
}
-fn unique_pointer(box dd: Box<(int, int, int)>) {
+fn unique_pointer(box dd: Box<(isize, isize, isize)>) {
zzz(); // #break
}
-fn ref_binding(ref ee: (int, int, int)) {
+fn ref_binding(ref ee: (isize, isize, isize)) {
zzz(); // #break
}
-fn ref_binding_in_tuple((ref ff, gg): (int, (int, int))) {
+fn ref_binding_in_tuple((ref ff, gg): (isize, (isize, isize))) {
zzz(); // #break
}
zzz(); // #break
}
-fn multiple_arguments((oo, pp): (int, int), qq : int) {
+fn multiple_arguments((oo, pp): (isize, isize), qq : isize) {
zzz(); // #break
}
tuple_struct_with_ref_binding(TupleStruct(55.0, 56));
multiple_arguments((57, 58), 59);
- fn nested_function(rr: int, (ss, tt): (int, int)) {
+ fn nested_function(rr: isize, (ss, tt): (isize, isize)) {
zzz(); // #break
}
Unit(i32)
}
-struct TupleStruct (f64, int);
+struct TupleStruct (f64, isize);
fn main() {
// simple tuple
- let (a, b) : (int, bool) = (1, false);
+ let (a, b) : (isize, bool) = (1, false);
// nested tuple
- let (c, (d, e)) : (int, (u16, u16)) = (2, (3, 4));
+ let (c, (d, e)) : (isize, (u16, u16)) = (2, (3, 4));
// bind tuple-typed value to one name (destructure only first level)
- let (f, g) : (int, (u32, u32)) = (5, (6, 7));
+ let (f, g) : (isize, (u32, u32)) = (5, (6, 7));
// struct as tuple element
let (h, i, j) : (i16, Struct, i16) = (8, Struct { a: 9, b: 10 }, 11);
#![allow(unused_variables)]
#![omit_gdb_pretty_printer_section]
-fn immediate_args(a: int, b: bool, c: f64) {
+fn immediate_args(a: isize, b: bool, c: f64) {
::std::old_io::print("") // #break
}
}
}
-fn fun(x: int, y: bool) -> (int, bool) {
+fn fun(x: isize, y: bool) -> (isize, bool) {
zzz(); // #break
(x, y)
#![omit_gdb_pretty_printer_section]
#[no_stack_check]
-fn immediate_args(a: int, b: bool, c: f64) {
+fn immediate_args(a: isize, b: bool, c: f64) {
::std::old_io::print("");
}
#![feature(old_io)]
#![omit_gdb_pretty_printer_section]
-fn immediate_args(a: int, b: bool, c: f64) {
+fn immediate_args(a: isize, b: bool, c: f64) {
()
}
// gdb-check:$5 = CStyleEnumVar3
struct RegularStruct {
- the_first_field: int,
+ the_first_field: isize,
the_second_field: f64,
the_third_field: bool,
}
use self::NestedEnum::{NestedVariant1, NestedVariant2};
struct RegularStruct {
- the_first_field: int,
+ the_first_field: isize,
the_second_field: f64,
the_third_field: bool,
the_fourth_field: &'static str,
let mixed_enum_struct_var = MixedEnumStructVar { field1: 108.5, field2: 109 };
let some = Some(110_usize);
- let none: Option<int> = None;
+ let none: Option<isize> = None;
let some_fat = Some("abc");
let none_fat: Option<&'static str> = None;
}
};
- let none_check1: Option<(uint, Vec<uint>)> = None;
+ let none_check1: Option<(usize, Vec<usize>)> = None;
let none_check2: Option<String> = None;
zzz(); // #break
#[derive(Clone)]
struct Struct {
- a: int,
+ a: isize,
b: f64
}
impl<T1> Struct<T1> {
- fn self_by_ref<T2>(&self, arg1: int, arg2: T2) -> int {
+ fn self_by_ref<T2>(&self, arg1: isize, arg2: T2) -> isize {
zzz(); // #break
arg1
}
- fn self_by_val<T2>(self, arg1: int, arg2: T2) -> int {
+ fn self_by_val<T2>(self, arg1: isize, arg2: T2) -> isize {
zzz(); // #break
arg1
}
- fn self_owned<T2>(self: Box<Struct<T1>>, arg1: int, arg2: T2) -> int {
+ fn self_owned<T2>(self: Box<Struct<T1>>, arg1: isize, arg2: T2) -> isize {
zzz(); // #break
arg1
}
#![omit_gdb_pretty_printer_section]
struct Struct {
- x: int
+ x: isize
}
impl Struct {
- fn static_method<T1, T2>(arg1: T1, arg2: T2) -> int {
+ fn static_method<T1, T2>(arg1: T1, arg2: T2) -> isize {
zzz(); // #break
return 0;
}
}
enum Enum {
- Variant1 { x: int },
+ Variant1 { x: isize },
Variant2,
- Variant3(f64, int, char),
+ Variant3(f64, isize, char),
}
impl Enum {
- fn static_method<T1, T2, T3>(arg1: T1, arg2: T2, arg3: T3) -> int {
+ fn static_method<T1, T2, T3>(arg1: T1, arg2: T2, arg3: T3) -> isize {
zzz(); // #break
return 1;
}
fn main() {
- // In order to avoid endianess trouble all of the following test values consist of a single
+ // In order to avoid endianness trouble all of the following test values consist of a single
// repeated byte. This way each interpretation of the union should look the same, no matter if
// this is a big or little endian machine.
// lldb-check:[...]$2 = AGenericStruct<f64, i32> { key: 4.5, value: 5 }
// lldb-command:print float_int_float
-// lldb-check:[...]$3 = AGenericStruct<f64, generic-struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
+// lldb-check:[...]$3 = AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
#![omit_gdb_pretty_printer_section]
#![omit_gdb_pretty_printer_section]
struct Struct {
- x: int
+ x: isize
}
trait Trait<T1> {
- fn generic_static_default_method<T2>(arg1: int, arg2: &(T1, T2)) -> int {
+ fn generic_static_default_method<T2>(arg1: isize, arg2: &(T1, T2)) -> isize {
zzz(); // #break
arg1
}
fn main() {
// Is this really how to use these?
- Trait::generic_static_default_method::<int, Struct, float>(1000, &(1, 2.5));
- Trait::generic_static_default_method::<float, Struct, (int, int, int)>(2000, &(3.5, (4, 5, 6)));
+ Trait::generic_static_default_method::<isize, Struct, float>(1000, &(1, 2.5));
+ Trait::generic_static_default_method::<float, Struct, (isize, isize, isize)>(2000,
+ &(3.5, (4, 5, 6)));
}
fn main() {
- // In order to avoid endianess trouble all of the following test values consist of a single
+ // In order to avoid endianness trouble all of the following test values consist of a single
// repeated byte. This way each interpretation of the union should look the same, no matter if
// this is a big or little endian machine.
// contained in the output, after calling `next` just once, we can be sure that we did not stop in
// unwrap(). (The testing framework doesn't allow for checking that some text is *not* contained in
// the output, which is why we have to make the test in this kind of roundabout way)
-fn bar() -> int {
+fn bar() -> isize {
let s = Some(5).unwrap(); // #break
s
}
#![omit_gdb_pretty_printer_section]
struct Struct {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
fn main() {
zzz(); // #break
sentinel();
- let closure = |x: int| {
+ let closure = |x: isize| {
zzz(); // #break
sentinel();
zzz(); // #break
sentinel();
- let unique_closure = |x:int| {
+ let unique_closure = |x:isize| {
zzz(); // #break
sentinel();
// gdb-command:run
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$1 = 0
// STRUCT EXPRESSION
// gdb-command:print val
// gdb-check:$4 = 11
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$5 = 1
// gdb-command:print ten
// gdb-check:$6 = 10
// gdb-command:print val
// gdb-check:$11 = 12
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$12 = 2
// gdb-command:print ten
// gdb-check:$13 = 10
// gdb-command:print val
// gdb-check:$18 = 13
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$19 = 3
// gdb-command:print ten
// gdb-check:$20 = 10
// gdb-command:print val
// gdb-check:$25 = 14
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$26 = 4
// gdb-command:print ten
// gdb-check:$27 = 10
// gdb-command:print val
// gdb-check:$32 = 15
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$33 = 5
// gdb-command:print ten
// gdb-check:$34 = 10
// gdb-command:print val
// gdb-check:$39 = 16
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$40 = 6
// gdb-command:print ten
// gdb-check:$41 = 10
// gdb-command:print val
// gdb-check:$46 = 17
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$47 = 7
// gdb-command:print ten
// gdb-check:$48 = 10
// gdb-command:print val
// gdb-check:$53 = 18
-// gdb-command:print 'lexical-scopes-in-block-expression::MUT_INT'
+// gdb-command:print 'lexical_scopes_in_block_expression::MUT_INT'
// gdb-check:$54 = 8
// gdb-command:print ten
// gdb-check:$55 = 10
#![allow(unused_assignments)]
#![omit_gdb_pretty_printer_section]
-static mut MUT_INT: int = 0;
+static mut MUT_INT: isize = 0;
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
-fn a_function(x: int) -> int {
+fn a_function(x: isize) -> isize {
x + 1
}
zzz(); // #break
sentinel();
- val as uint
+ val as usize
}];
zzz(); // #break
fn zzz() {()}
-fn some_function(a: int, b: int) {
+fn some_function(a: isize, b: isize) {
let some_variable = Struct { a: 11, b: 22 };
let some_other_variable = 23;
}
}
-fn some_other_function(a: int, b: int) -> bool { true }
+fn some_other_function(a: isize, b: isize) -> bool { true }
impl Enum {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_by_val(self, arg1: int, arg2: int) -> int {
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_owned(self: Box<Enum>, arg1: int, arg2: int) -> int {
+ fn self_owned(self: Box<Enum>, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
impl<T> Struct<T> {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_by_val(self, arg1: int, arg2: int) -> int {
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_owned(self: Box<Struct<T>>, arg1: int, arg2: int) -> int {
+ fn self_owned(self: Box<Struct<T>>, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
#[derive(Copy)]
struct Struct {
- x: int
+ x: isize
}
impl Struct {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
self.x + arg1 + arg2
}
- fn self_by_val(self, arg1: int, arg2: int) -> int {
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
self.x + arg1 + arg2
}
- fn self_owned(self: Box<Struct>, arg1: int, arg2: int) -> int {
+ fn self_owned(self: Box<Struct>, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
self.x + arg1 + arg2
}
#[derive(Copy)]
struct Struct {
- x: int
+ x: isize
}
trait Trait {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int;
- fn self_by_val(self, arg1: int, arg2: int) -> int;
- fn self_owned(self: Box<Self>, arg1: int, arg2: int) -> int;
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize;
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize;
+ fn self_owned(self: Box<Self>, arg1: isize, arg2: isize) -> isize;
}
impl Trait for Struct {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
self.x + arg1 + arg2
}
- fn self_by_val(self, arg1: int, arg2: int) -> int {
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
self.x + arg1 + arg2
}
- fn self_owned(self: Box<Struct>, arg1: int, arg2: int) -> int {
+ fn self_owned(self: Box<Struct>, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
self.x + arg1 + arg2
}
#![omit_gdb_pretty_printer_section]
#[derive(Copy)]
-struct TupleStruct(int, f64);
+struct TupleStruct(isize, f64);
impl TupleStruct {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_by_val(self, arg1: int, arg2: int) -> int {
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_owned(self: Box<TupleStruct>, arg1: int, arg2: int) -> int {
+ fn self_owned(self: Box<TupleStruct>, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
struct LongCycleWithAnonymousTypes {
next: Opt<Box<Box<Box<Box<Box<LongCycleWithAnonymousTypes>>>>>>,
- value: uint,
+ value: usize,
}
// This test case makes sure that recursive structs are properly described. The Node structs are
#[derive(Copy)]
struct Struct {
- x: int
+ x: isize
}
trait Trait : Sized {
- fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_by_val(self, arg1: int, arg2: int) -> int {
+ fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
- fn self_owned(self: Box<Self>, arg1: int, arg2: int) -> int {
+ fn self_owned(self: Box<Self>, arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
#[derive(Copy)]
struct Struct {
- x: int
+ x: isize
}
trait Trait : Sized {
- fn self_by_ref<T>(&self, arg1: int, arg2: T) -> int {
+ fn self_by_ref<T>(&self, arg1: isize, arg2: T) -> isize {
zzz(); // #break
arg1
}
- fn self_by_val<T>(self, arg1: int, arg2: T) -> int {
+ fn self_by_val<T>(self, arg1: isize, arg2: T) -> isize {
zzz(); // #break
arg1
}
- fn self_owned<T>(self: Box<Self>, arg1: int, arg2: T) -> int {
+ fn self_owned<T>(self: Box<Self>, arg1: isize, arg2: T) -> isize {
zzz(); // #break
arg1
}
// === GDB TESTS ===================================================================================
-// gdb-command:print 'simple-struct::NO_PADDING_16'
+// gdb-command:print 'simple_struct::NO_PADDING_16'
// gdb-check:$1 = {x = 1000, y = -1001}
-// gdb-command:print 'simple-struct::NO_PADDING_32'
+// gdb-command:print 'simple_struct::NO_PADDING_32'
// gdb-check:$2 = {x = 1, y = 2, z = 3}
-// gdb-command:print 'simple-struct::NO_PADDING_64'
+// gdb-command:print 'simple_struct::NO_PADDING_64'
// gdb-check:$3 = {x = 4, y = 5, z = 6}
-// gdb-command:print 'simple-struct::NO_PADDING_163264'
+// gdb-command:print 'simple_struct::NO_PADDING_163264'
// gdb-check:$4 = {a = 7, b = 8, c = 9, d = 10}
-// gdb-command:print 'simple-struct::INTERNAL_PADDING'
+// gdb-command:print 'simple_struct::INTERNAL_PADDING'
// gdb-check:$5 = {x = 11, y = 12}
-// gdb-command:print 'simple-struct::PADDING_AT_END'
+// gdb-command:print 'simple_struct::PADDING_AT_END'
// gdb-check:$6 = {x = 13, y = 14}
// gdb-command:run
// gdb-command:print padding_at_end
// gdb-check:$12 = {x = -10014, y = 10015}
-// gdb-command:print 'simple-struct::NO_PADDING_16'
+// gdb-command:print 'simple_struct::NO_PADDING_16'
// gdb-check:$13 = {x = 100, y = -101}
-// gdb-command:print 'simple-struct::NO_PADDING_32'
+// gdb-command:print 'simple_struct::NO_PADDING_32'
// gdb-check:$14 = {x = -15, y = -16, z = 17}
-// gdb-command:print 'simple-struct::NO_PADDING_64'
+// gdb-command:print 'simple_struct::NO_PADDING_64'
// gdb-check:$15 = {x = -18, y = 19, z = 20}
-// gdb-command:print 'simple-struct::NO_PADDING_163264'
+// gdb-command:print 'simple_struct::NO_PADDING_163264'
// gdb-check:$16 = {a = -21, b = 22, c = 23, d = 24}
-// gdb-command:print 'simple-struct::INTERNAL_PADDING'
+// gdb-command:print 'simple_struct::INTERNAL_PADDING'
// gdb-check:$17 = {x = 25, y = -26}
-// gdb-command:print 'simple-struct::PADDING_AT_END'
+// gdb-command:print 'simple_struct::PADDING_AT_END'
// gdb-check:$18 = {x = -27, y = 28}
// gdb-command:continue
// === GDB TESTS ===================================================================================
-// gdb-command:print/d 'simple-tuple::NO_PADDING_8'
+// gdb-command:print/d 'simple_tuple::NO_PADDING_8'
// gdb-check:$1 = {-50, 50}
-// gdb-command:print 'simple-tuple::NO_PADDING_16'
+// gdb-command:print 'simple_tuple::NO_PADDING_16'
// gdb-check:$2 = {-1, 2, 3}
-// gdb-command:print 'simple-tuple::NO_PADDING_32'
+// gdb-command:print 'simple_tuple::NO_PADDING_32'
// gdb-check:$3 = {4, 5, 6}
-// gdb-command:print 'simple-tuple::NO_PADDING_64'
+// gdb-command:print 'simple_tuple::NO_PADDING_64'
// gdb-check:$4 = {7, 8, 9}
-// gdb-command:print 'simple-tuple::INTERNAL_PADDING_1'
+// gdb-command:print 'simple_tuple::INTERNAL_PADDING_1'
// gdb-check:$5 = {10, 11}
-// gdb-command:print 'simple-tuple::INTERNAL_PADDING_2'
+// gdb-command:print 'simple_tuple::INTERNAL_PADDING_2'
// gdb-check:$6 = {12, 13, 14, 15}
-// gdb-command:print 'simple-tuple::PADDING_AT_END'
+// gdb-command:print 'simple_tuple::PADDING_AT_END'
// gdb-check:$7 = {16, 17}
// gdb-command:run
// gdb-command:print paddingAtEnd
// gdb-check:$14 = {15, 16}
-// gdb-command:print/d 'simple-tuple::NO_PADDING_8'
+// gdb-command:print/d 'simple_tuple::NO_PADDING_8'
// gdb-check:$15 = {-127, 127}
-// gdb-command:print 'simple-tuple::NO_PADDING_16'
+// gdb-command:print 'simple_tuple::NO_PADDING_16'
// gdb-check:$16 = {-10, 10, 9}
-// gdb-command:print 'simple-tuple::NO_PADDING_32'
+// gdb-command:print 'simple_tuple::NO_PADDING_32'
// gdb-check:$17 = {14, 15, 16}
-// gdb-command:print 'simple-tuple::NO_PADDING_64'
+// gdb-command:print 'simple_tuple::NO_PADDING_64'
// gdb-check:$18 = {17, 18, 19}
-// gdb-command:print 'simple-tuple::INTERNAL_PADDING_1'
+// gdb-command:print 'simple_tuple::INTERNAL_PADDING_1'
// gdb-check:$19 = {110, 111}
-// gdb-command:print 'simple-tuple::INTERNAL_PADDING_2'
+// gdb-command:print 'simple_tuple::INTERNAL_PADDING_2'
// gdb-check:$20 = {112, 113, 114, 115}
-// gdb-command:print 'simple-tuple::PADDING_AT_END'
+// gdb-command:print 'simple_tuple::PADDING_AT_END'
// gdb-check:$21 = {116, 117}
#![omit_gdb_pretty_printer_section]
struct Struct {
- x: int
+ x: isize
}
impl Struct {
- fn static_method(arg1: int, arg2: int) -> int {
+ fn static_method(arg1: isize, arg2: isize) -> isize {
zzz(); // #break
arg1 + arg2
}
}
enum Enum {
- Variant1 { x: int },
+ Variant1 { x: isize },
Variant2,
- Variant3(f64, int, char),
+ Variant3(f64, isize, char),
}
impl Enum {
- fn static_method(arg1: int, arg2: f64, arg3: uint) -> int {
+ fn static_method(arg1: isize, arg2: f64, arg3: usize) -> isize {
zzz(); // #break
arg1
}
fn main() {
- // In order to avoid endianess trouble all of the following test values consist of a single
+ // In order to avoid endianness trouble all of the following test values consist of a single
// repeated byte. This way each interpretation of the union should look the same, no matter if
// this is a big or little endian machine.
fn main() {
- // In order to avoid endianess trouble all of the following test values consist of a single
+ // In order to avoid endianness trouble all of the following test values consist of a single
// repeated byte. This way each interpretation of the union should look the same, no matter if
// this is a big or little endian machine.
#![omit_gdb_pretty_printer_section]
struct Struct {
- x: int
+ x: isize
}
trait Trait {
- fn generic_static_default_method<T>(arg1: int, arg2: T) -> int {
+ fn generic_static_default_method<T>(arg1: isize, arg2: T) -> isize {
zzz(); // #break
arg1
}
// Is this really how to use these?
Trait::generic_static_default_method::<Struct, float>(1000, 0.5);
- Trait::generic_static_default_method::<Struct, &(int, int, int)>(2000, &(1, 2, 3));
+ Trait::generic_static_default_method::<Struct, &(isize, isize, isize)>(2000, &(1, 2, 3));
}
#![omit_gdb_pretty_printer_section]
trait Trait {
- fn method(&self) -> int { 0 }
+ fn method(&self) -> isize { 0 }
}
struct Struct {
- a: int,
+ a: isize,
b: f64
}
fn main() {
- // In order to avoid endianess trouble all of the following test values consist of a single
+ // In order to avoid endianness trouble all of the following test values consist of a single
// repeated byte. This way each interpretation of the union should look the same, no matter if
// this is a big or little endian machine.
// gdb-check:type = struct Struct1
// gdb-command:whatis generic_struct1
-// gdb-check:type = struct GenericStruct<type-names::Mod1::Struct2, type-names::Mod1::Mod2::Struct3>
+// gdb-check:type = struct GenericStruct<type_names::Mod1::Struct2, type_names::Mod1::Mod2::Struct3>
// gdb-command:whatis generic_struct2
-// gdb-check:type = struct GenericStruct<type-names::Struct1, extern "fastcall" fn(isize) -> usize>
+// gdb-check:type = struct GenericStruct<type_names::Struct1, extern "fastcall" fn(isize) -> usize>
// gdb-command:whatis mod_struct
// gdb-check:type = struct Struct2
// gdb-check:type = union Enum2
// gdb-command:whatis generic_enum_1
-// gdb-check:type = union Enum3<type-names::Mod1::Struct2>
+// gdb-check:type = union Enum3<type_names::Mod1::Struct2>
// gdb-command:whatis generic_enum_2
-// gdb-check:type = union Enum3<type-names::Struct1>
+// gdb-check:type = union Enum3<type_names::Struct1>
// TUPLES
// gdb-command:whatis tuple1
-// gdb-check:type = struct (u32, type-names::Struct1, type-names::Mod1::Mod2::Enum3<type-names::Mod1::Struct2>)
+// gdb-check:type = struct (u32, type_names::Struct1, type_names::Mod1::Mod2::Enum3<type_names::Mod1::Struct2>)
// gdb-command:whatis tuple2
-// gdb-check:type = struct ((type-names::Struct1, type-names::Mod1::Mod2::Struct3), type-names::Mod1::Enum2, char)
+// gdb-check:type = struct ((type_names::Struct1, type_names::Mod1::Mod2::Struct3), type_names::Mod1::Enum2, char)
// BOX
// gdb-check:type = struct (Box<f32>, i32)
// gdb-command:whatis box2
-// gdb-check:type = struct (Box<type-names::Mod1::Mod2::Enum3<f32>>, i32)
+// gdb-check:type = struct (Box<type_names::Mod1::Mod2::Enum3<f32>>, i32)
// REFERENCES
// gdb-command:whatis ref1
-// gdb-check:type = struct (&type-names::Struct1, i32)
+// gdb-check:type = struct (&type_names::Struct1, i32)
// gdb-command:whatis ref2
-// gdb-check:type = struct (&type-names::GenericStruct<char, type-names::Struct1>, i32)
+// gdb-check:type = struct (&type_names::GenericStruct<char, type_names::Struct1>, i32)
// gdb-command:whatis mut_ref1
-// gdb-check:type = struct (&mut type-names::Struct1, i32)
+// gdb-check:type = struct (&mut type_names::Struct1, i32)
// gdb-command:whatis mut_ref2
-// gdb-check:type = struct (&mut type-names::GenericStruct<type-names::Mod1::Enum2, f64>, i32)
+// gdb-check:type = struct (&mut type_names::GenericStruct<type_names::Mod1::Enum2, f64>, i32)
// RAW POINTERS
// gdb-command:whatis mut_ptr1
-// gdb-check:type = struct (*mut type-names::Struct1, isize)
+// gdb-check:type = struct (*mut type_names::Struct1, isize)
// gdb-command:whatis mut_ptr2
// gdb-check:type = struct (*mut isize, isize)
// gdb-command:whatis mut_ptr3
-// gdb-check:type = struct (*mut type-names::Mod1::Mod2::Enum3<type-names::Struct1>, isize)
+// gdb-check:type = struct (*mut type_names::Mod1::Mod2::Enum3<type_names::Struct1>, isize)
// gdb-command:whatis const_ptr1
-// gdb-check:type = struct (*const type-names::Struct1, isize)
+// gdb-check:type = struct (*const type_names::Struct1, isize)
// gdb-command:whatis const_ptr2
// gdb-check:type = struct (*const isize, isize)
// gdb-command:whatis const_ptr3
-// gdb-check:type = struct (*const type-names::Mod1::Mod2::Enum3<type-names::Struct1>, isize)
+// gdb-check:type = struct (*const type_names::Mod1::Mod2::Enum3<type_names::Struct1>, isize)
// VECTORS
// gdb-command:whatis fixed_size_vec1
-// gdb-check:type = struct ([type-names::Struct1; 3], i16)
+// gdb-check:type = struct ([type_names::Struct1; 3], i16)
// gdb-command:whatis fixed_size_vec2
// gdb-check:type = struct ([usize; 3], i16)
// gdb-check:type = struct &[usize]
// gdb-command:whatis slice2
-// gdb-check:type = struct &[type-names::Mod1::Enum2]
+// gdb-check:type = struct &[type_names::Mod1::Enum2]
// TRAITS
// gdb-check:type = struct &mut Trait1
// gdb-command:whatis generic_box_trait
-// gdb-check:type = struct Box<Trait2<i32, type-names::Mod1::Struct2>>
+// gdb-check:type = struct Box<Trait2<i32, type_names::Mod1::Struct2>>
// gdb-command:whatis generic_ref_trait
-// gdb-check:type = struct &Trait2<type-names::Struct1, type-names::Struct1>
+// gdb-check:type = struct &Trait2<type_names::Struct1, type_names::Struct1>
// gdb-command:whatis generic_mut_ref_trait
-// gdb-check:type = struct &mut Trait2<type-names::Mod1::Mod2::Struct3, type-names::GenericStruct<usize, isize>>
+// gdb-check:type = struct &mut Trait2<type_names::Mod1::Mod2::Struct3, type_names::GenericStruct<usize, isize>>
// BARE FUNCTIONS
// gdb-command:whatis rust_fn
-// gdb-check:type = struct (fn(core::option::Option<isize>, core::option::Option<&type-names::Mod1::Struct2>), usize)
+// gdb-check:type = struct (fn(core::option::Option<isize>, core::option::Option<&type_names::Mod1::Struct2>), usize)
// gdb-command:whatis extern_c_fn
// gdb-check:type = struct (extern "C" fn(isize), usize)
// gdb-check:type = struct (fn(f64) -> usize, usize)
// gdb-command:whatis extern_c_fn_with_return_value
-// gdb-check:type = struct (extern "C" fn() -> type-names::Struct1, usize)
+// gdb-check:type = struct (extern "C" fn() -> type_names::Struct1, usize)
// gdb-command:whatis unsafe_fn_with_return_value
-// gdb-check:type = struct (unsafe fn(type-names::GenericStruct<u16, u8>) -> type-names::Mod1::Struct2, usize)
+// gdb-check:type = struct (unsafe fn(type_names::GenericStruct<u16, u8>) -> type_names::Mod1::Struct2, usize)
// gdb-command:whatis extern_stdcall_fn_with_return_value
// gdb-check:type = struct (extern "stdcall" fn(Box<isize>) -> usize, usize)
// gdb-check:type = struct (fn(isize) -> isize, usize)
// gdb-command:whatis generic_function_struct3
-// gdb-check:type = struct (fn(type-names::Mod1::Mod2::Struct3) -> type-names::Mod1::Mod2::Struct3, usize)
+// gdb-check:type = struct (fn(type_names::Mod1::Mod2::Struct3) -> type_names::Mod1::Mod2::Struct3, usize)
// gdb-command:whatis variadic_function
// gdb-check:type = struct (unsafe extern "C" fn(*const u8, ...) -> isize, usize)
fn main() {
- // In order to avoid endianess trouble all of the following test values consist of a single
+ // In order to avoid endianness trouble all of the following test values consist of a single
// repeated byte. This way each interpretation of the union should look the same, no matter if
// this is a big or little endian machine.
#![omit_gdb_pretty_printer_section]
struct Struct {
- a: int,
+ a: isize,
b: f64,
- c: uint
+ c: usize
}
fn main() {
#![omit_gdb_pretty_printer_section]
struct Struct {
- a: int,
+ a: isize,
b: f64,
- c: uint
+ c: usize
}
fn main() {
immedate_env();
}
-fn do_something(_: &int, _:&int, _:&int) {
+fn do_something(_: &isize, _:&isize, _:&isize) {
}
#![omit_gdb_pretty_printer_section]
struct Struct {
- a: int,
+ a: isize,
b: f64,
- c: uint
+ c: usize
}
fn main() {
// gdb-command:print padded_struct.data_ptr[1]
// gdb-check:$13 = {x = 13, y = 14, z = 15}
-// gdb-command:print 'vec-slices::MUT_VECT_SLICE'.length
+// gdb-command:print 'vec_slices::MUT_VECT_SLICE'.length
// gdb-check:$14 = 2
-// gdb-command:print *((int64_t[2]*)('vec-slices::MUT_VECT_SLICE'.data_ptr))
+// gdb-command:print *((int64_t[2]*)('vec_slices::MUT_VECT_SLICE'.data_ptr))
// gdb-check:$15 = {64, 65}
// except according to those terms.
-extern crate
- "foo"suffix //~ ERROR extern crate name with a suffix is illegal
- //~^ WARNING: obsolete syntax
- as foo;
-
extern
"C"suffix //~ ERROR ABI spec with a suffix is illegal
fn foo() {}
--- /dev/null
+// Copyright 2015 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 main() {
+ let _ = b"\u{a66e}";
+ //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
+
+ let _ = b'\u{a66e}';
+ //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
+
+ let _ = b'\u';
+ //~^ ERROR unknown byte escape: u
+
+ let _ = b'\x5';
+ //~^ ERROR numeric character escape is too short
+
+ let _ = b'\xxy';
+ //~^ ERROR illegal character in numeric character escape: x
+ //~^^ ERROR illegal character in numeric character escape: y
+
+ let _ = '\x5';
+ //~^ ERROR numeric character escape is too short
+
+ let _ = '\xxy';
+ //~^ ERROR illegal character in numeric character escape: x
+ //~^^ ERROR illegal character in numeric character escape: y
+
+ let _ = b"\u{a4a4} \xf \u";
+ //~^ ERROR unicode escape sequences cannot be used as a byte or in a byte string
+ //~^^ ERROR illegal character in numeric character escape:
+ //~^^^ ERROR unknown byte escape: u
+
+ let _ = "\u{ffffff} \xf \u";
+ //~^ ERROR illegal unicode character escape
+ //~^^ ERROR illegal character in numeric character escape:
+ //~^^^ ERROR form of character escape may only be used with characters in the range [\x00-\x7f]
+ //~^^^^ ERROR unknown character escape: u
+}
// except according to those terms.
pub fn main() {
- let s = "\u{lol}"; //~ ERROR illegal character in unicode escape
+ let s = "\u{lol}";
+ //~^ ERROR illegal character in unicode escape: l
+ //~^^ ERROR illegal character in unicode escape: o
+ //~^^^ ERROR illegal character in unicode escape: l
}
// except according to those terms.
// pp-exact
-fn f() -> [int; 3] {
+fn f() -> [isize; 3] {
let picard = 0;
let data = 1;
fn test1() { let val = &0; { } *val; }
-fn test2() -> int { let val = &0; { } *val }
+fn test2() -> isize { let val = &0; { } *val }
#[derive(Copy)]
-struct S { eax: int }
+struct S { eax: isize }
fn test3() {
let regs = &Cell::new(S {eax: 0});
fn test4() -> bool { let regs = &true; if true { } *regs || false }
-fn test5() -> (int, int) { { } (0, 1) }
+fn test5() -> (isize, isize) { { } (0, 1) }
fn test6() -> bool { { } (true || false) && true }
-fn test7() -> uint {
+fn test7() -> usize {
let regs = &0;
match true { true => { } _ => { } }
- (*regs < 2) as uint
+ (*regs < 2) as usize
}
-fn test8() -> int {
+fn test8() -> isize {
let val = &0;
match true {
true => { }
match true { true => { } _ => { } } regs.set(regs.get() + 1);
}
-fn test10() -> int {
+fn test10() -> isize {
let regs = vec!(0);
match true { true => { } _ => { } }
regs[0]
}
-fn test11() -> Vec<int> { if true { } vec!(1, 2) }
+fn test11() -> Vec<isize> { if true { } vec!(1, 2) }
fn call_this<F>(f: F) where F: Fn(&str) + Send { }
-fn call_that<F>(f: F) where F: for<'a>Fn(&'a int, &'a int) -> int { }
+fn call_that<F>(f: F) where F: for<'a>Fn(&'a isize, &'a isize) -> isize { }
-fn call_extern(f: fn() -> int) { }
+fn call_extern(f: fn() -> isize) { }
-fn call_abid_extern(f: extern "C" fn() -> int) { }
+fn call_abid_extern(f: extern "C" fn() -> isize) { }
pub fn main() { }
// preserved. They are needed to disambiguate `{return n+1}; - 0` from
// `({return n+1}-0)`.
-fn id<F>(f: F) -> int where F: Fn() -> int { f() }
+fn id<F>(f: F) -> isize where F: Fn() -> isize { f() }
-fn wsucc(_n: int) -> int { id(|| { 1 }) - 0 }
+fn wsucc(_n: isize) -> isize { id(|| { 1 }) - 0 }
fn main() { }
// pp-exact
-fn f<F>(f: F) where F: Fn(int) { f(10) }
+fn f<F>(f: F) where F: Fn(isize) { f(10) }
fn main() { f(|i| { assert!(i == 10) }) }
// except according to those terms.
trait X { fn dummy(&self) { } }
-impl X for uint { }
+impl X for usize { }
trait Y { fn dummy(&self) { } }
-impl Y for uint { }
+impl Y for usize { }
// Issue #759
// Whitespace under block opening should not expand forever
-fn a() -> uint {
+fn a() -> usize {
1
}
// pp-exact
-fn f(v: &[int]) -> int {
+fn f(v: &[isize]) -> isize {
let mut n = 0;
for e in v {
n = *e; // This comment once triggered pretty printer bug
+++ /dev/null
-// Copyright 2012 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 f() { if (1 == panic!()) { } else { } }
-
-fn main() { }
trait Tr {
fn dummy(&self) { }
}
-impl Tr for int { }
+impl Tr for isize { }
fn foo<'a>(x: Box<Tr+ Sync + 'a>) -> Box<Tr+ Sync + 'a> { x }
// ignore-test
// pp-exact
struct Thing {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
fn main() {
// pp-exact
struct Foo;
-struct Bar(int, int);
+struct Bar(isize, isize);
fn main() {
struct Foo2;
- struct Bar2(int, int, int);
+ struct Bar2(isize, isize, isize);
let _a = Bar(5, 5);
let _b = Foo;
}
fn foo(&self);
}
-unsafe impl UnsafeTrait for int {
+unsafe impl UnsafeTrait for isize {
fn foo(&self) { }
}
fn f() { }
-fn block_semi() -> int { { f() }; -1 }
+fn block_semi() -> isize { { f() }; -1 }
-fn block_nosemi() -> int { ({ 0 }) - 1 }
+fn block_nosemi() -> isize { ({ 0 }) - 1 }
-fn if_semi() -> int { if true { f() } else { f() }; -1 }
+fn if_semi() -> isize { if true { f() } else { f() }; -1 }
-fn if_nosemi() -> int { (if true { 0 } else { 0 }) - 1 }
+fn if_nosemi() -> isize { (if true { 0 } else { 0 }) - 1 }
-fn alt_semi() -> int { match true { true => { f() } _ => { } }; -1 }
+fn alt_semi() -> isize { match true { true => { f() } _ => { } }; -1 }
-fn alt_no_semi() -> int { (match true { true => { 0 } _ => { 1 } }) - 1 }
+fn alt_no_semi() -> isize { (match true { true => { 0 } _ => { 1 } }) - 1 }
fn stmt() { { f() }; -1; }
// pp-exact
-fn f<'a, 'b, T>(t: T) -> int where T: 'a, 'a:'b, T: Eq { 0 }
+fn f<'a, 'b, T>(t: T) -> isize where T: 'a, 'a:'b, T: Eq { 0 }
fn main() { }
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f(_a: int, _b: int, _c: Box<int>) { panic!("moop"); }
+fn f(_a: isize, _b: isize, _c: Box<isize>) { panic!("moop"); }
fn main() { f(1, panic!("meep"), box 42); }
--- /dev/null
+// 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.
+
+// error-pattern:quux
+fn foo() -> ! { panic!("quux"); }
+fn main() {
+ foo() == foo(); // these types wind up being defaulted to ()
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:index out of bounds: the len is 3 but the index is
+// error-pattern:assertion failed: index < self.len()
use std::usize;
use std::mem::size_of;
// ignore-test
// error-pattern:index out of bounds
-use std::uint;
+use std::usize;
fn main() {
let x = vec!(1_usize,2_usize,3_usize);
// length (in bytes), because the scaling of the index will cause it to
// wrap around to a small number.
- let idx = uint::MAX & !(uint::MAX >> 1_usize);
+ let idx = usize::MAX & !(usize::MAX >> 1_usize);
println!("ov2 idx = 0x%x", idx);
// This should panic.
let idx = u64::MAX & !(u64::MAX >> 1_usize);
println!("ov3 idx = 0x%8.8x%8.8x",
- (idx >> 32) as uint,
- idx as uint);
+ (idx >> 32) as usize,
+ idx as usize);
// This should panic.
println!("ov3 0x%x", x[idx]);
let x = vec!(1_usize,2_usize,3_usize);
- let base = x.as_ptr() as uint;
- let idx = base / mem::size_of::<uint>();
+ let base = x.as_ptr() as usize;
+ let idx = base / mem::size_of::<usize>();
println!("ov1 base = 0x{:x}", base);
println!("ov1 idx = 0x{:x}", idx);
- println!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>());
- println!("ov1 idx * sizeof::<uint>() = 0x{:x}",
- idx * mem::size_of::<uint>());
+ println!("ov1 sizeof::<usize>() = 0x{:x}", mem::size_of::<usize>());
+ println!("ov1 idx * sizeof::<usize>() = 0x{:x}",
+ idx * mem::size_of::<usize>());
// This should panic.
println!("ov1 0x{:x}", x[idx]);
use std::marker::PhantomData;
-fn test00_start(ch: chan_t<int>, message: int) { send(ch, message); }
+fn test00_start(ch: chan_t<isize>, message: isize) { send(ch, message); }
-type task_id = int;
-type port_id = int;
+type task_id = isize;
+type port_id = isize;
struct chan_t<T> {
task: task_id,
// error-pattern:test
fn main() {
- let __isize: int = panic!("test");
+ let __isize: isize = panic!("test");
}
fn f() -> ! { panic!() }
-fn g() -> int { let x = if true { f() } else { 10 }; return x; }
+fn g() -> isize { let x = if true { f() } else { 10 }; return x; }
fn main() { g(); }
fn f() -> ! { panic!() }
-fn g() -> int { let x = match true { true => { f() } false => { 10 } }; return x; }
+fn g() -> isize { let x = match true { true => { f() } false => { 10 } }; return x; }
fn main() { g(); }
}
}
-fn count(n: uint) -> uint {
+fn count(n: usize) -> usize {
unsafe {
task::deschedule();
rustrt::rust_dbg_call(cb, n)
// except according to those terms.
// error-pattern:Number is odd
-fn even(x: uint) -> bool {
+fn even(x: usize) -> bool {
if x < 2 {
return false;
} else if x == 2 { return true; } else { return even(x - 2); }
}
-fn foo(x: uint) {
+fn foo(x: usize) {
if even(x) {
println!("{}", x);
} else {
// error-pattern: task '<main>' has overflowed its stack
struct R {
- b: int,
+ b: isize,
}
impl Drop for R {
enum e<T> { ee(Arc<T>) }
-fn foo() -> e<int> {panic!();}
+fn foo() -> e<isize> {panic!();}
fn main() {
let _f = foo();
#![allow(unused_variables)]
-struct Point { x: int, y: int }
+struct Point { x: isize, y: isize }
fn main() {
let origin = Point {x: 0, y: 0};
fn main() {
let i =
- match Some::<int>(3) { None::<int> => { panic!() } Some::<int>(_) => { panic!() } };
+ match Some::<isize>(3) { None::<isize> => { panic!() } Some::<isize>(_) => { panic!() } };
foo(i);
}
// error-pattern:quux
fn f() -> ! { panic!("quux") }
-fn g() -> int { match f() { true => { 1 } false => { 0 } } }
+fn g() -> isize { match f() { true => { 1 } false => { 0 } } }
fn main() { g(); }
// except according to those terms.
// error-pattern:squirrelcupcake
-fn cmp() -> int {
+fn cmp() -> isize {
match (Some('a'), None::<char>) {
(Some(_), _) => { panic!("squirrelcupcake"); }
(_, Some(_)) => { panic!(); }
// except according to those terms.
// error-pattern:woe
-fn f(a: int) { println!("{}", a); }
+fn f(a: isize) { println!("{}", a); }
fn main() { f(panic!("woe")); }
use std::result::Result::Err;
fn main() {
- println!("{}", Err::<int,String>("kitty".to_string()).unwrap());
+ println!("{}", Err::<isize,String>("kitty".to_string()).unwrap());
}
use std::thread;
struct r {
- x:int,
+ x:isize,
}
// Setting the exit status after the runtime has already
}
}
-fn r(x:int) -> r {
+fn r(x:isize) -> r {
r {
x: x
}
// error-pattern:fail
-fn build() -> Vec<int> {
+fn build() -> Vec<isize> {
panic!();
}
-struct Blk { node: Vec<int> }
+struct Blk { node: Vec<isize> }
fn main() {
let _blk = Blk {
// error-pattern:fail
-fn build1() -> Vec<int> {
+fn build1() -> Vec<isize> {
vec!(0,0,0,0,0,0,0)
}
-fn build2() -> Vec<int> {
+fn build2() -> Vec<isize> {
panic!();
}
-struct Blk { node: Vec<int> , span: Vec<int> }
+struct Blk { node: Vec<isize> , span: Vec<isize> }
fn main() {
let _blk = Blk {
fn main() {
- let v: Vec<int> = vec!(10);
- let x: uint = 0;
+ let v: Vec<isize> = vec!(10);
+ let x: usize = 0;
assert_eq!(v[x], 10);
// Bounds-check panic.
#![allow(while_true)]
// error-pattern:quux
-fn main() { let _x: int = { while true { panic!("quux"); } ; 8 } ; }
+fn main() { let _x: isize = { while true { panic!("quux"); } ; 8 } ; }
use std::dynamic_lib::DynamicLibrary;
use std::os;
-use std::old_path::Path;
+use std::path::Path;
pub fn main() {
unsafe {
let path = Path::new("libdylib.so");
let a = DynamicLibrary::open(Some(&path)).unwrap();
- assert!(a.symbol::<int>("fun1").is_ok());
- assert!(a.symbol::<int>("fun2").is_err());
- assert!(a.symbol::<int>("fun3").is_err());
- assert!(a.symbol::<int>("fun4").is_ok());
- assert!(a.symbol::<int>("fun5").is_ok());
+ assert!(a.symbol::<isize>("fun1").is_ok());
+ assert!(a.symbol::<isize>("fun2").is_err());
+ assert!(a.symbol::<isize>("fun3").is_err());
+ assert!(a.symbol::<isize>("fun4").is_ok());
+ assert!(a.symbol::<isize>("fun5").is_ok());
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
pub fn pat_vec_7() {
match [7, 77, 777, 7777] {
[x, y, ..] => x + y
#![feature(asm)]
#![crate_type="lib"]
-pub fn exit(n: uint) {
+pub fn exit(n: usize) {
unsafe {
// Pretend this asm is an exit() syscall.
asm!("" :: "r"(n) :: "volatile");
use std::intrinsics;
-pub fn exit(n: uint) -> ! {
+pub fn exit(n: usize) -> ! {
unsafe {
// Pretend this asm is an exit() syscall.
asm!("" :: "r"(n) :: "volatile");
}
fn main() {
- outer::<int>();
- outer::<uint>();
- outer_foreign::<int>();
- outer_foreign::<uint>();
+ outer::<isize>();
+ outer::<usize>();
+ outer_foreign::<isize>();
+ outer_foreign::<usize>();
}
#![crate_name = "foo"]
#![crate_type = "rlib"]
-static FOO: uint = 3;
+static FOO: usize = 3;
-pub fn foo() -> &'static uint { &FOO }
+pub fn foo() -> &'static usize { &FOO }
#![crate_type = "rlib"]
#![crate_type = "dylib"]
-pub static foo: int = 4;
+pub static foo: isize = 4;
use std::mem;
-pub fn addr() -> uint { unsafe { mem::transmute(&both::foo) } }
+pub fn addr() -> usize { unsafe { mem::transmute(&both::foo) } }
use std::mem;
fn main() {
- assert_eq!(unsafe { mem::transmute::<&int, uint>(&both::foo) },
+ assert_eq!(unsafe { mem::transmute::<&isize, usize>(&both::foo) },
dylib::addr());
}
--- /dev/null
+-include ../tools.mk
+
+all:
+ $(RUSTC) foo-bar.rs
+ [ -f $(TMPDIR)/$(call BIN,foo-bar) ]
+ [ -f $(TMPDIR)/libfoo_bar.rlib ]
--- /dev/null
+// Copyright 2015 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.
+
+#![crate_type = "lib"]
+#![crate_type = "bin"]
+
+fn main() {}
extern crate serialize;
#[derive(Encodable)] pub struct A;
-#[derive(Encodable)] pub struct B(int);
-#[derive(Encodable)] pub struct C { x: int }
+#[derive(Encodable)] pub struct B(isize);
+#[derive(Encodable)] pub struct C { x: isize }
#[derive(Encodable)] pub enum D {}
#[derive(Encodable)] pub enum E { y }
-#[derive(Encodable)] pub enum F { z(int) }
+#[derive(Encodable)] pub enum F { z(isize) }
-fn foo_method(&self) -> &'static str { return "i am very similiar to foo."; }
+fn foo_method(&self) -> &'static str { return "i am very similar to foo."; }
/* nest::S::foo_method */
struct S;
impl S {
fn foo_method(&self) -> &'static str {
- return "i am very similiar to foo.";
+ return "i am very similar to foo.";
}
}
}
pub trait Doge { fn dummy(&self) { } }
// @has foo/bar/struct.Foo.html
- pub struct Foo { x: int, y: uint }
+ pub struct Foo { x: isize, y: usize }
// @has foo/bar/fn.prawns.html
- pub fn prawns((a, b): (int, uint), Foo { x, y }: Foo) { }
+ pub fn prawns((a, b): (isize, usize), Foo { x, y }: Foo) { }
}
extern crate graphviz;
// A simple rust project
-extern crate "flate" as myflate;
+extern crate flate as myflate;
use std::collections::{HashMap,HashSet};
use std::cell::RefCell;
let y = x.1;
}
-struct TupStruct(int, int, Box<str>);
+struct TupStruct(isize, isize, Box<str>);
-fn test_tup_struct(x: TupStruct) -> int {
+fn test_tup_struct(x: TupStruct) -> isize {
x.1
}
#![crate_type = "rlib"]
#[inline]
-pub fn cci_fn() -> uint {
+pub fn cci_fn() -> usize {
1234
}
// except according to those terms.
extern crate cci_lib;
-use cci_lib::{cci_fn};
+use cci_lib::cci_fn;
-fn call1() -> uint {
+fn call1() -> usize {
cci_fn()
}
mod a {
use cci_lib::cci_fn;
- pub fn call2() -> uint {
+ pub fn call2() -> usize {
cci_fn()
}
}
mod b {
- pub fn call3() -> uint {
+ pub fn call3() -> usize {
0
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn magic_fn() -> uint {
+fn magic_fn() -> usize {
1234
}
mod a {
- pub fn magic_fn() -> uint {
+ pub fn magic_fn() -> usize {
2345
}
}
mod b {
- pub fn magic_fn() -> uint {
+ pub fn magic_fn() -> usize {
3456
}
}
pub static Y: &'static [u8] = include_bytes!("lib.rs");
trait Foo { fn dummy(&self) { } }
-impl Foo for uint {}
+impl Foo for usize {}
pub fn dummy() {
// force the vtable to be created
- let _x = &1u as &Foo;
+ let _x = &1us as &Foo;
}
trait Sized : PhantomFn<Self> { }
#[lang="start"]
-fn start(_main: *const u8, _argc: int, _argv: *const *const u8) -> int { 0 }
+fn start(_main: *const u8, _argc: isize, _argv: *const *const u8) -> isize { 0 }
extern {
fn _foo() -> [u8; 16];
pub fn main() {
unsafe {
- let mut i : int = 1;
+ let mut i : isize = 1;
volatile_store(&mut i, 2);
assert_eq!(volatile_load(&i), 2);
}
| grep "invalid character.*in crate name:"
cp foo.rs $(TMPDIR)/-foo.rs
$(RUSTC) $(TMPDIR)/-foo.rs 2>&1 \
- | grep "soon cannot contain hyphens:"
+ | grep 'crate names cannot start with a `-`'
// Regression test for issue #13560, the test itself is all in the dependent
// libraries. The fail which previously failed to compile is the one numbered 3.
-extern crate "issue-13560-2" as t2;
-extern crate "issue-13560-3" as t3;
+extern crate issue_13560_2 as t2;
+extern crate issue_13560_3 as t3;
fn main() {}
// aux-build:issue-16822.rs
-extern crate "issue-16822" as lib;
+extern crate issue_16822 as lib;
use std::cell::RefCell;
struct App {
- i: int
+ i: isize
}
impl lib::Update for App {
// aux-build:issue-18502.rs
-extern crate "issue-18502" as fmt;
+extern crate issue_18502 as fmt;
fn main() {
::fmt::baz();
fn syntax_extension(cx: &ExtCtxt) {
let _toks_1 = vec![quote_tokens!(cx, /** comment */ fn foo() {})];
let name = quote_tokens!(cx, bar);
- let _toks_2 = vec![quote_item!(cx, static $name:int = 2;)];
+ let _toks_2 = vec![quote_item!(cx, static $name:isize = 2;)];
let _toks_4 = quote_tokens!(cx, $name:static $name:sizeof);
let _toks_3 = vec![quote_item!(cx,
/// comment
- fn foo() { let $name:int = 3; }
+ fn foo() { let $name:isize = 3; }
)];
}
check_pp(ext_cx, abc, pprust::print_expr, "23".to_string());
- let ty = quote_ty!(cx, int);
- check_pp(ext_cx, ty, pprust::print_type, "int".to_string());
+ let ty = quote_ty!(cx, isize);
+ check_pp(ext_cx, ty, pprust::print_type, "isize".to_string());
- let item = quote_item!(cx, static x : int = 10;).get();
- check_pp(ext_cx, item, pprust::print_item, "static x: int = 10;".to_string());
+ let item = quote_item!(cx, static x : isize = 10;).get();
+ check_pp(ext_cx, item, pprust::print_item, "static x: isize = 10;".to_string());
let stmt = quote_stmt!(cx, let x = 20;);
check_pp(ext_cx, *stmt, pprust::print_stmt, "let x = 20;".to_string());
let p_toks : Vec<syntax::ast::TokenTree> = quote_tokens!(cx, (x, 1 .. 4, *));
let a: P<syntax::ast::Expr> = quote_expr!(cx, 1 + 2);
- let _b: Option<P<syntax::ast::Item>> = quote_item!(cx, static foo : int = $e_toks; );
+ let _b: Option<P<syntax::ast::Item>> = quote_item!(cx, static foo : isize = $e_toks; );
let _c: P<syntax::ast::Pat> = quote_pat!(cx, (x, 1 .. 4, *) );
let _d: Option<P<syntax::ast::Stmt>> = quote_stmt!(cx, let x = $a; );
let _d: syntax::ast::Arm = quote_arm!(cx, (ref x, ref y) = (x, y) );
let i: Option<P<syntax::ast::Item>> = quote_item!(cx, #[derive(Eq)] struct Foo; );
assert!(i.is_some());
- let _l: P<syntax::ast::Ty> = quote_ty!(cx, &int);
+ let _l: P<syntax::ast::Ty> = quote_ty!(cx, &isize);
let _m: Vec<syntax::ast::TokenTree> = quote_matcher!(cx, $($foo:tt,)* bar);
let _n: syntax::ast::Attribute = quote_attr!(cx, #![cfg(foo, bar = "baz")]);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-static mut DROP_RAN: int = 0;
+static mut DROP_RAN: isize = 0;
struct Foo;
impl Drop for Foo {
enum sty { ty_nil, }
-struct RawT {struct_: sty, cname: Option<String>, hash: uint}
+struct RawT {struct_: sty, cname: Option<String>, hash: usize}
fn mk_raw_ty(st: sty, cname: Option<String>) -> RawT {
return RawT {struct_: st, cname: cname, hash: 0};
fn f<T>() -> Vec<T> { return Vec::new(); }
-pub fn main() { let mut r: R<int> = R {v: Vec::new()}; r.v = f(); }
+pub fn main() { let mut r: R<isize> = R {v: Vec::new()}; r.v = f(); }
// except according to those terms.
struct Foo {
- x: int
+ x: isize
}
impl Foo {
// pretty-expanded FIXME #23616
struct X {
- x: int
+ x: isize
}
-fn f1(a: &mut X, b: &mut int, c: int) -> int {
+fn f1(a: &mut X, b: &mut isize, c: isize) -> isize {
let r = a.x + *b + c;
a.x = 0;
*b = 10;
return r;
}
-fn f2<F>(a: int, f: F) -> int where F: FnOnce(int) { f(1); return a; }
+fn f2<F>(a: isize, f: F) -> isize where F: FnOnce(isize) { f(1); return a; }
pub fn main() {
let mut a = X {x: 1};
pub fn main() {
- let a: int = 10;
+ let a: isize = 10;
println!("{}", a);
assert_eq!(a * (a - 1), 90);
}
pub fn main() {
- let i32_a: int = 10;
+ let i32_a: isize = 10;
assert_eq!(i32_a, 10);
assert_eq!(i32_a - 10, 0);
assert_eq!(i32_a / 10, 1);
assert_eq!(i32_a * i32_a * i32_a, 1000);
assert_eq!(i32_a * i32_a * i32_a * i32_a, 10000);
assert_eq!(i32_a * i32_a / i32_a * i32_a, 100);
- assert_eq!(i32_a * (i32_a - 1) << (2 + i32_a as uint), 368640);
- let i32_b: int = 0x10101010;
+ assert_eq!(i32_a * (i32_a - 1) << (2 + i32_a as usize), 368640);
+ let i32_b: isize = 0x10101010;
assert_eq!(i32_b + 1 - 1, i32_b);
assert_eq!(i32_b << 1, i32_b << 1);
assert_eq!(i32_b >> 1, i32_b >> 1);
// pretty-expanded FIXME #23616
pub fn main() {
- let i32_c: int = 0x10101010;
+ let i32_c: isize = 0x10101010;
assert!(i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3));
}
// pretty-expanded FIXME #23616
-fn f() -> int { { return 3; } }
+fn f() -> isize { { return 3; } }
pub fn main() { assert!((f() == 3)); }
// pretty-expanded FIXME #23616
fn main() {
- assert_eq!(3 as uint * 3, 9);
- assert_eq!(3 as (uint) * 3, 9);
- assert_eq!(3 as (uint) / 3, 1);
- assert_eq!(3 as uint + 3, 6);
- assert_eq!(3 as (uint) + 3, 6);
+ assert_eq!(3 as usize * 3, 9);
+ assert_eq!(3 as (usize) * 3, 9);
+ assert_eq!(3 as (usize) / 3, 1);
+ assert_eq!(3 as usize + 3, 6);
+ assert_eq!(3 as (usize) + 3, 6);
}
assert_eq!(2147483648, next_power_of_2(2147483647));
}
- let mut y: int = 5;
- let x: int;
+ let mut y: isize = 5;
+ let x: isize;
unsafe {
// Treat the output as initialization.
asm!(
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn main() {
- let x: int;
+ let x: isize;
unsafe {
// Treat the output as initialization.
asm!("mov $1, $0" : "=r"(x) : "r"(5_usize));
// except according to those terms.
#[derive(PartialEq, Debug)]
-struct Point { x : int }
+struct Point { x : isize }
pub fn main() {
assert_eq!(14,14);
// pretty-expanded FIXME #23616
fn test_assign() {
- let mut x: int;
+ let mut x: isize;
let y: () = x = 10;
assert_eq!(x, 10);
assert_eq!(y, ());
}
fn test_assign_op() {
- let mut x: int = 0;
+ let mut x: isize = 0;
let y: () = x += 10;
assert_eq!(x, 10);
assert_eq!(y, ());
}
}
-fn length<A, T: iterable<A>>(x: T) -> uint {
+fn length<A, T: iterable<A>>(x: T) -> usize {
let mut len = 0;
x.iterate(|_y| {
len += 1;
}
pub fn main() {
- let x: Vec<int> = vec!(0,1,2,3);
+ let x: Vec<isize> = vec!(0,1,2,3);
// Call a method
- x.iterate(|y| { assert!(x[*y as uint] == *y); true });
+ x.iterate(|y| { assert!(x[*y as usize] == *y); true });
// Call a parameterized function
assert_eq!(length(x.clone()), x.len());
// Call a parameterized function, with type arguments that require
// a borrow
- assert_eq!(length::<int, &[int]>(&*x), x.len());
+ assert_eq!(length::<isize, &[isize]>(&*x), x.len());
// Now try it with a type that *needs* to be borrowed
let z = [0,1,2,3];
// Call a parameterized function
- assert_eq!(length::<int, &[int]>(&z), z.len());
+ assert_eq!(length::<isize, &[isize]>(&z), z.len());
}
}
impl Foo for i32 {
- type T = int;
+ type T = isize;
}
fn main() {
let x: <i32 as Foo>::T = 22;
- let y: int = 44;
+ let y: isize = 44;
assert_eq!(x * 2, y);
}
#[derive(PartialEq)]
pub struct Bar;
-impl Foo for int {
- type A = uint;
- fn boo(&self) -> uint { 42 }
+impl Foo for isize {
+ type A = usize;
+ fn boo(&self) -> usize { 42 }
}
impl Foo for char {
x.boo()
}
-fn foo_uint<I: Foo<A=uint>>(x: I) -> uint {
+fn foo_uint<I: Foo<A=usize>>(x: I) -> usize {
x.boo()
}
// Test that we are able to reference cross-crate traits that employ
// associated types.
-extern crate "associated-types-cc-lib" as bar;
+extern crate associated_types_cc_lib as bar;
use bar::Bar;
fn convert(self) -> Self::Opposite;
}
-impl SignedUnsigned for int {
- type Opposite = uint;
+impl SignedUnsigned for isize {
+ type Opposite = usize;
- fn convert(self) -> uint {
- self as uint
+ fn convert(self) -> usize {
+ self as usize
}
}
-impl SignedUnsigned for uint {
- type Opposite = int;
+impl SignedUnsigned for usize {
+ type Opposite = isize;
- fn convert(self) -> int {
- self as int
+ fn convert(self) -> isize {
+ self as isize
}
}
-fn get(x: int) -> <int as SignedUnsigned>::Opposite {
+fn get(x: isize) -> <isize as SignedUnsigned>::Opposite {
x.convert()
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn pairwise_sub(mut t: Box<DoubleEndedIterator<Item=int>>) -> int {
+fn pairwise_sub(mut t: Box<DoubleEndedIterator<Item=isize>>) -> isize {
let mut result = 0;
loop {
let front = t.next();
}
struct Struct {
- x: int,
+ x: isize,
}
impl Get for Struct {
- type Value = int;
- fn get(&self) -> &int {
+ type Value = isize;
+ fn get(&self) -> &isize {
&self.x
}
}
}
struct Struct {
- x: int,
+ x: isize,
}
impl Get for Struct {
- type Value = int;
- fn get(&self) -> &int {
+ type Value = isize;
+ fn get(&self) -> &isize {
&self.x
}
}
}
struct Struct {
- x: int,
+ x: isize,
}
impl Get for Struct {
- type Value = int;
- fn get(&self) -> &int {
+ type Value = isize;
+ fn get(&self) -> &isize {
&self.x
}
}
}
struct Struct {
- x: int,
+ x: isize,
}
impl Get for Struct {
- type Value = int;
- fn get(&self) -> &int {
+ type Value = isize;
+ fn get(&self) -> &isize {
&self.x
}
}
use std::marker::MarkerTrait;
-impl X for f64 { type Y = int; }
+impl X for f64 { type Y = isize; }
trait X : MarkerTrait { type Y; }
fn main() {}
// pretty-expanded FIXME #23616
-fn pairwise_sub<T:DoubleEndedIterator<Item=int>>(mut t: T) -> int {
+fn pairwise_sub<T:DoubleEndedIterator<Item=isize>>(mut t: T) -> isize {
let mut result = 0;
loop {
let front = t.next();
}
trait Int: Not<Result=Self> + Sized {
- fn count_ones(self) -> uint;
- fn count_zeros(self) -> uint {
+ fn count_ones(self) -> usize;
+ fn count_zeros(self) -> usize {
// neither works
let x: Self = self.not();
0
fn dummy(&self) { }
}
-impl Foo for int {
- type Bar = int;
+impl Foo for isize {
+ type Bar = isize;
}
struct Thing<F: Foo> {
trait Trait<'a> {
type T: 'static;
- type U: Get<&'a int>;
+ type U: Get<&'a isize>;
fn dummy(&'a self) { }
}
#[derive(PartialEq)]
pub struct Bar;
-impl Foo for int {
- type A = uint;
- fn boo(&self) -> uint { 42 }
+impl Foo for isize {
+ type A = usize;
+ fn boo(&self) -> usize { 42 }
}
impl Foo for Bar {
- type A = int;
- fn boo(&self) -> int { 43 }
+ type A = isize;
+ fn boo(&self) -> isize { 43 }
}
impl Foo for char {
}
struct Struct {
- x: int,
+ x: isize,
}
impl Get for Struct {
- type Value = int;
- fn get(&self) -> &int {
+ type Value = isize;
+ fn get(&self) -> &isize {
&self.x
}
}
fn boo(&self) -> Self::A;
}
-impl Foo for int {
- type A = uint;
- fn boo(&self) -> uint {
+impl Foo for isize {
+ type A = usize;
+ fn boo(&self) -> usize {
5
}
}
}
pub fn main() {
- let z: uint = bar(2, 4);
+ let z: usize = bar(2, 4);
}
}
pub fn main() {
- assert_eq!(size_of::<int>(), size_of::<Test<int>>());
+ assert_eq!(size_of::<isize>(), size_of::<Test<isize>>());
}
#![feature(start)]
#[start]
-fn start(_argc: int, _argv: *const *const u8) -> int {
+fn start(_argc: isize, _argv: *const *const u8) -> isize {
return 0;
}
#[derive(Decodable, Encodable)]
enum Expr {
- Val(uint),
+ Val(usize),
Plus(@Expr, @Expr),
Minus(@Expr, @Expr)
}
impl cmp::Eq for CLike {
fn eq(&self, other: &CLike) -> bool {
- (*self) as int == *other as int
+ (*self) as isize == *other as isize
}
fn ne(&self, other: &CLike) -> bool { !self.eq(other) }
}
#[derive(Decodable, Encodable, Eq)]
struct Spanned<T> {
- lo: uint,
- hi: uint,
+ lo: usize,
+ hi: usize,
node: T,
}
#[derive(Decodable, Encodable)]
-struct SomeStruct { v: Vec<uint> }
+struct SomeStruct { v: Vec<usize> }
#[derive(Decodable, Encodable)]
-struct Point {x: uint, y: uint}
+struct Point {x: usize, y: usize}
#[derive(Decodable, Encodable)]
enum Quark<T> {
#[derive(Debug)]
struct Pair<T, U> { a: T, b: U }
-struct Triple { x: int, y: int, z: int }
+struct Triple { x: isize, y: isize, z: isize }
fn f<T,U>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
}
struct Bar {
- x: int
+ x: isize
}
trait Baz {
// except according to those terms.
struct Foo {
- x: int,
+ x: isize,
}
trait Stuff {
fn f<T>(x: Vec<T>) -> T { return x.into_iter().next().unwrap(); }
-fn g<F>(act: F) -> int where F: FnOnce(Vec<int>) -> int { return act(vec!(1, 2, 3)); }
+fn g<F>(act: F) -> isize where F: FnOnce(Vec<isize>) -> isize { return act(vec!(1, 2, 3)); }
pub fn main() {
assert_eq!(g(f), 1);
// pretty-expanded FIXME #23616
struct Foo {
- x: int,
+ x: isize,
}
impl Foo {
#![feature(box_syntax)]
trait double {
- fn double(self: Box<Self>) -> uint;
+ fn double(self: Box<Self>) -> usize;
}
-impl double for uint {
- fn double(self: Box<uint>) -> uint { *self * 2 }
+impl double for usize {
+ fn double(self: Box<usize>) -> usize { *self * 2 }
}
pub fn main() {
- let x: Box<_> = box() (box 3u as Box<double>);
+ let x: Box<_> = box() (box 3us as Box<double>);
assert_eq!(x.double(), 6);
}
#![feature(box_syntax)]
trait double {
- fn double(self) -> uint;
+ fn double(self) -> usize;
}
-impl double for uint {
- fn double(self) -> uint { self }
+impl double for usize {
+ fn double(self) -> usize { self }
}
-impl double for Box<uint> {
- fn double(self) -> uint { *self * 2 }
+impl double for Box<usize> {
+ fn double(self) -> usize { *self * 2 }
}
pub fn main() {
#![feature(box_syntax)]
trait double {
- fn double(self: Box<Self>) -> uint;
+ fn double(self: Box<Self>) -> usize;
}
-impl double for Box<uint> {
- fn double(self: Box<Box<uint>>) -> uint { **self * 2 }
+impl double for Box<usize> {
+ fn double(self: Box<Box<usize>>) -> usize { **self * 2 }
}
pub fn main() {
#![feature(box_syntax)]
trait double {
- fn double(self: Box<Self>) -> uint;
+ fn double(self: Box<Self>) -> usize;
}
-impl double for uint {
- fn double(self: Box<uint>) -> uint { *self * 2 }
+impl double for usize {
+ fn double(self: Box<usize>) -> usize { *self * 2 }
}
pub fn main() {
#![feature(box_syntax)]
trait double {
- fn double(self: Box<Self>) -> uint;
+ fn double(self: Box<Self>) -> usize;
}
-impl double for uint {
- fn double(self: Box<uint>) -> uint { *self * 2 }
+impl double for usize {
+ fn double(self: Box<usize>) -> usize { *self * 2 }
}
pub fn main() {
}
}
-impl Foo for uint {
+impl Foo for usize {
fn foo(&self) -> String {
format!("{}", *self)
}
// pretty-expanded FIXME #23616
pub fn main() {
- struct Foo { x: int, y: int }
+ struct Foo { x: isize, y: isize }
let mut f = Foo { x: 10, y: 0 };
match f {
Foo { ref mut x, .. } => *x = 11,
--- /dev/null
+// Copyright 2015 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::ops::Mul;
+
+#[derive(Copy)]
+pub struct Foo {
+ x: f64,
+}
+
+impl Mul<Foo> for f64 {
+ type Output = Foo;
+
+ fn mul(self, rhs: Foo) -> Foo {
+ // intentionally do something that is not *
+ Foo { x: self + rhs.x }
+ }
+}
+
+pub fn main() {
+ let f: Foo = Foo { x: 5.0 };
+ let val: f64 = 3.0;
+ let f2: Foo = val * f;
+ assert_eq!(f2.x, 8.0);
+}
#[derive(PartialEq, Debug)]
struct p {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
-fn p(x: int, y: int) -> p {
+fn p(x: isize, y: isize) -> p {
p {
x: x,
y: y
unsafe {
println!("q = {:x}, r = {:x}",
- (::std::mem::transmute::<*const p, uint>(&q)),
- (::std::mem::transmute::<*const p, uint>(&r)));
+ (::std::mem::transmute::<*const p, usize>(&q)),
+ (::std::mem::transmute::<*const p, usize>(&r)));
}
assert_eq!(q, r);
r.y = 17;
#[cfg(any(target_arch = "x86", target_arch = "arm"))]
fn target() {
- assert_eq!(-1000 as uint >> 3_usize, 536870787_usize);
+ assert_eq!(-1000 as usize >> 3_usize, 536870787_usize);
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
fn target() {
- assert_eq!(-1000 as uint >> 3_usize, 2305843009213693827_usize);
+ assert_eq!(-1000 as usize >> 3_usize, 2305843009213693827_usize);
}
fn general() {
- let mut a: int = 1;
- let mut b: int = 2;
+ let mut a: isize = 1;
+ let mut b: isize = 2;
a ^= b;
b ^= a;
a = a ^ b;
const BAR: () = ();
struct Data;
use m::f;
-extern crate "blind-item-mixed-crate-use-item-foo" as foo;
+extern crate blind_item_mixed_crate_use_item_foo as foo;
fn main() {
const BAR2: () = ();
struct Data2;
use m::g;
- extern crate "blind-item-mixed-crate-use-item-foo2" as foo2;
+ extern crate blind_item_mixed_crate_use_item_foo2 as foo2;
f(Data, BAR, foo::X);
g(Data2, BAR2, foo2::Y);
// pretty-expanded FIXME #23616
-fn asBlock<F>(f: F) -> uint where F: FnOnce() -> uint {
+fn asBlock<F>(f: F) -> usize where F: FnOnce() -> usize {
return f();
}
// pretty-expanded FIXME #23616
-fn force<F>(f: F) -> int where F: FnOnce() -> int { return f(); }
+fn force<F>(f: F) -> isize where F: FnOnce() -> isize { return f(); }
pub fn main() {
- fn f() -> int { return 7; }
+ fn f() -> isize { return 7; }
assert_eq!(force(f), 7);
let g = {||force(f)};
assert_eq!(g(), 7);
fn foo(self);
}
-impl<'a> Foo for &'a [int] {
+impl<'a> Foo for &'a [isize] {
fn foo(self) {}
}
// pretty-expanded FIXME #23616
-struct Foo(int, int);
+struct Foo(isize, isize);
fn main() {
let x = (1, 2);
pub fn main() {
struct A {
- a: int,
+ a: isize,
w: B,
}
struct B {
- a: int
+ a: isize
}
let mut p = A {
a: 1,
// pretty-expanded FIXME #23616
-struct F { f: Vec<int> }
+struct F { f: Vec<isize> }
-fn impure(_v: &[int]) {
+fn impure(_v: &[isize]) {
}
pub fn main() {
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn borrow<F>(x: &int, f: F) where F: FnOnce(&int) {
+fn borrow<F>(x: &isize, f: F) where F: FnOnce(&isize) {
f(x)
}
-fn test1(x: &Box<int>) {
+fn test1(x: &Box<isize>) {
borrow(&*(*x).clone(), |p| {
- let x_a = &**x as *const int;
- assert!((x_a as uint) != (p as *const int as uint));
+ let x_a = &**x as *const isize;
+ assert!((x_a as usize) != (p as *const isize as usize));
assert_eq!(unsafe{*x_a}, *p);
})
}
// pretty-expanded FIXME #23616
-fn foo<'a>(mut t0: &'a mut int,
- mut t1: &'a mut int) {
- let p: &int = &*t0; // Freezes `*t0`
+fn foo<'a>(mut t0: &'a mut isize,
+ mut t1: &'a mut isize) {
+ let p: &isize = &*t0; // Freezes `*t0`
let mut t2 = &t0;
- let q: &int = &**t2; // Freezes `*t0`, but that's ok...
- let r: &int = &*t0; // ...after all, could do same thing directly.
+ let q: &isize = &**t2; // Freezes `*t0`, but that's ok...
+ let r: &isize = &*t0; // ...after all, could do same thing directly.
}
pub fn main() {
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct A { a: int, b: Box<int> }
-struct B { a: Box<int>, b: Box<int> }
+struct A { a: isize, b: Box<isize> }
+struct B { a: Box<isize>, b: Box<isize> }
fn move_after_copy() {
let x = A { a: 1, b: box 2 };
data: &'a mut [T]
}
-fn get<'a, T>(ms: &'a MutSlice<'a, T>, index: uint) -> &'a T {
+fn get<'a, T>(ms: &'a MutSlice<'a, T>, index: usize) -> &'a T {
&ms.data[index]
}
// pretty-expanded FIXME #23616
-fn borrow(_v: &int) {}
+fn borrow(_v: &isize) {}
-fn borrow_from_arg_imm_ref(v: Box<int>) {
+fn borrow_from_arg_imm_ref(v: Box<isize>) {
borrow(&*v);
}
-fn borrow_from_arg_mut_ref(v: &mut Box<int>) {
+fn borrow_from_arg_mut_ref(v: &mut Box<isize>) {
borrow(&**v);
}
-fn borrow_from_arg_copy(v: Box<int>) {
+fn borrow_from_arg_copy(v: Box<isize>) {
borrow(&*v);
}
#![feature(box_syntax)]
struct Foo {
- a: int
+ a: isize
}
pub enum Bar {
- Bar1, Bar2(int, Box<Bar>),
+ Bar1, Bar2(isize, Box<Bar>),
}
impl Foo {
}
}
- fn check_id(&mut self, s: int) { panic!() }
+ fn check_id(&mut self, s: isize) { panic!() }
}
pub fn main() { }
pub fn main() {
let bar: Box<_> = box 3;
- let h = || -> int { *bar };
+ let h = || -> isize { *bar };
assert_eq!(h(), 3);
}
use std::mem::swap;
#[derive(Debug)]
-struct Ints {sum: Box<int>, values: Vec<int> }
+struct Ints {sum: Box<isize>, values: Vec<isize> }
-fn add_int(x: &mut Ints, v: int) {
+fn add_int(x: &mut Ints, v: isize) {
*x.sum += v;
let mut values = Vec::new();
swap(&mut values, &mut x.values);
swap(&mut values, &mut x.values);
}
-fn iter_ints<F>(x: &Ints, mut f: F) -> bool where F: FnMut(&int) -> bool {
+fn iter_ints<F>(x: &Ints, mut f: F) -> bool where F: FnMut(&isize) -> bool {
let l = x.values.len();
(0..l).all(|i| f(&x.values[i]))
}
add_int(&mut *ints, 44);
iter_ints(&*ints, |i| {
- println!("int = {:?}", *i);
+ println!("isize = {:?}", *i);
true
});
// pretty-expanded FIXME #23616
-fn want_slice(v: &[int]) -> int {
+fn want_slice(v: &[isize]) -> isize {
let mut sum = 0;
for i in v { sum += *i; }
sum
}
-fn has_mut_vec(v: Vec<int> ) -> int {
+fn has_mut_vec(v: Vec<isize> ) -> isize {
want_slice(&v)
}
// Test that (safe) nested calls with `&mut` receivers are permitted.
-struct Foo {a: uint, b: uint}
+struct Foo {a: usize, b: usize}
impl Foo {
- pub fn inc_a(&mut self, v: uint) { self.a += v; }
+ pub fn inc_a(&mut self, v: usize) { self.a += v; }
- pub fn next_b(&mut self) -> uint {
+ pub fn next_b(&mut self) -> usize {
let b = self.b;
self.b += 1;
b
// ignore-pretty
-fn match_ref(v: Option<int>) -> int {
+fn match_ref(v: Option<isize>) -> isize {
match v {
Some(ref i) => {
*i
}
}
-fn match_ref_unused(v: Option<int>) {
+fn match_ref_unused(v: Option<isize>) {
match v {
Some(_) => {}
None => {}
}
}
-fn impure(_i: int) {
+fn impure(_i: isize) {
}
-fn match_imm_reg(v: &Option<int>) {
+fn match_imm_reg(v: &Option<isize>) {
match *v {
Some(ref i) => {impure(*i)} // OK because immutable
None => {}
}
}
-fn match_mut_reg(v: &mut Option<int>) {
+fn match_mut_reg(v: &mut Option<isize>) {
match *v {
Some(ref i) => {impure(*i)} // OK, frozen
None => {}
// pretty-expanded FIXME #23616
struct Counter {
- value: uint
+ value: usize
}
impl Counter {
- fn new(v: uint) -> Counter {
+ fn new(v: usize) -> Counter {
Counter {value: v}
}
self
}
- fn get(&self) -> uint {
+ fn get(&self) -> usize {
self.value
}
- fn get_and_inc(&mut self) -> uint {
+ fn get_and_inc(&mut self) -> usize {
let v = self.value;
self.value += 1;
v
// pretty-expanded FIXME #23616
struct Box {
- x: uint
+ x: usize
}
impl Box {
- fn get(&self) -> &uint {
+ fn get(&self) -> &usize {
&self.x
}
- fn set(&mut self, x: uint) {
+ fn set(&mut self, x: usize) {
self.x = x;
}
}
// pretty-expanded FIXME #23616
struct Rec {
- f: Box<int>,
+ f: Box<isize>,
}
struct Outer {
}
struct Innermost {
- h: Box<int>,
+ h: Box<isize>,
}
-fn borrow(_v: &int) {}
+fn borrow(_v: &isize) {}
-fn box_mut(v: &mut Box<int>) {
+fn box_mut(v: &mut Box<isize>) {
borrow(&**v); // OK: &mut -> &imm
}
borrow(&*v.f.g.h); // OK: &mut -> &imm
}
-fn box_imm(v: &Box<int>) {
+fn box_imm(v: &Box<isize>) {
borrow(&**v); // OK
}
#[derive(Copy)]
enum newtype {
- newvar(int)
+ newvar(isize)
}
pub fn main() {
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct A { a: int, b: Box<int> }
+struct A { a: isize, b: Box<isize> }
fn field_copy_after_field_borrow() {
let mut x = A { a: 1, b: box 2 };
// pretty-expanded FIXME #23616
-fn foo<'r>(s: &'r uint) -> bool {
+fn foo<'r>(s: &'r usize) -> bool {
match s {
&3 => true,
_ => false
// pretty-expanded FIXME #23616
-fn select<'r>(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> {
+fn select<'r>(x: &'r Option<isize>, y: &'r Option<isize>) -> &'r Option<isize> {
match (x, y) {
(&None, &None) => x,
(&Some(_), _) => x,
--- /dev/null
+// Copyright 2015 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.
+
+// Test that we cleanup a fixed size Box<[D; k]> properly when D has a
+// destructor.
+
+use std::thread;
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
+
+static LOG: AtomicUsize = ATOMIC_USIZE_INIT;
+
+struct D(u8);
+
+impl Drop for D {
+ fn drop(&mut self) {
+ println!("Dropping {}", self.0);
+ let old = LOG.load(Ordering::SeqCst);
+ LOG.compare_and_swap(old, old << 4 | self.0 as usize, Ordering::SeqCst);
+ }
+}
+
+fn main() {
+ fn die() -> D { panic!("Oh no"); }
+ let g = thread::spawn(|| {
+ let _b1: Box<[D; 4]> = Box::new([D( 1), D( 2), D( 3), D( 4)]);
+ let _b2: Box<[D; 4]> = Box::new([D( 5), D( 6), D( 7), D( 8)]);
+ let _b3: Box<[D; 4]> = Box::new([D( 9), D(10), die(), D(12)]);
+ let _b4: Box<[D; 4]> = Box::new([D(13), D(14), D(15), D(16)]);
+ });
+ assert!(g.join().is_err());
+
+ // When the panic occurs, we will be in the midst of constructing
+ // the input to `_b3`. Therefore, we drop the elements of the
+ // partially filled array first, before we get around to dropping
+ // the elements of `_b1` and _b2`.
+
+ // Issue 23222: The order in which the elements actually get
+ // dropped is a little funky. See similar notes in nested-vec-3;
+ // in essence, I would not be surprised if we change the ordering
+ // given in `expect` in the future.
+
+ let expect = 0x__A_9__5_6_7_8__1_2_3_4;
+ let actual = LOG.load(Ordering::SeqCst);
+ assert!(actual == expect, "expect: 0x{:x} actual: 0x{:x}", expect, actual);
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Test that we cleanup dynamic sized Box<[D]> properly when D has a
+// destructor.
+
+use std::thread;
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
+
+static LOG: AtomicUsize = ATOMIC_USIZE_INIT;
+
+struct D(u8);
+
+impl Drop for D {
+ fn drop(&mut self) {
+ println!("Dropping {}", self.0);
+ let old = LOG.load(Ordering::SeqCst);
+ LOG.compare_and_swap(old, old << 4 | self.0 as usize, Ordering::SeqCst);
+ }
+}
+
+fn main() {
+ fn die() -> D { panic!("Oh no"); }
+ let g = thread::spawn(|| {
+ let _b1: Box<[D; 4]> = Box::new([D( 1), D( 2), D( 3), D( 4)]);
+ let _b2: Box<[D; 4]> = Box::new([D( 5), D( 6), D( 7), D( 8)]);
+ let _b3: Box<[D; 4]> = Box::new([D( 9), D(10), die(), D(12)]);
+ let _b4: Box<[D; 4]> = Box::new([D(13), D(14), D(15), D(16)]);
+ });
+ assert!(g.join().is_err());
+
+ // When the panic occurs, we will be in the midst of constructing
+ // the input to `_b3`. Therefore, we drop the elements of the
+ // partially filled array first, before we get around to dropping
+ // the elements of `_b1` and _b2`.
+
+ // Issue 23222: The order in which the elements actually get
+ // dropped is a little funky. See similar notes in nested-vec-3;
+ // in essence, I would not be surprised if we change the ordering
+ // given in `expect` in the future.
+
+ let expect = 0x__A_9__5_6_7_8__1_2_3_4;
+ let actual = LOG.load(Ordering::SeqCst);
+ assert!(actual == expect, "expect: 0x{:x} actual: 0x{:x}", expect, actual);
+}
// pretty-expanded FIXME #23616
-fn int_id(x: int) -> int { return x; }
+fn int_id(x: isize) -> isize { return x; }
pub fn main() { loop { int_id(break); } }
s.say("hello")
}
-impl Speak for int {
+impl Speak for isize {
fn say(&self, s:&str) -> String {
format!("{}: {}", s, *self)
}
assert_eq!(3.hi(), "hello: 3".to_string());
assert_eq!(Some(Some(3)).hi(),
"something!something!hello: 3".to_string());
- assert_eq!(None::<int>.hi(), "hello - none".to_string());
+ assert_eq!(None::<isize>.hi(), "hello - none".to_string());
- assert_eq!(Some(None::<int>).hi(), "something!hello - none".to_string());
+ assert_eq!(Some(None::<isize>).hi(), "something!hello - none".to_string());
assert_eq!(Some(3).hi(), "something!hello: 3".to_string());
}
}
pub fn main() {
- let (tx, rx): (Sender<X<int>>, Receiver<X<int>>) = channel();
+ let (tx, rx): (Sender<X<isize>>, Receiver<X<isize>>) = channel();
foo(X(31337), tx);
assert!(rx.recv().unwrap() == X(31337));
}
}
pub fn main() {
- let (tx, rx): (Sender<int>, Receiver<int>) = channel();
+ let (tx, rx): (Sender<isize>, Receiver<isize>) = channel();
foo(31337, tx);
assert!(rx.recv().unwrap() == 31337);
}
extern crate trait_superkinds_in_metadata;
use trait_superkinds_in_metadata::{RequiresRequiresShareAndSend, RequiresShare};
-use trait_superkinds_in_metadata::{RequiresCopy};
+use trait_superkinds_in_metadata::RequiresCopy;
use std::marker;
#[derive(Copy)]
trait Foo : Send { }
-impl Foo for int { }
+impl Foo for isize { }
pub fn main() { }
// pretty-expanded FIXME #23616
struct X {
- a: int
+ a: isize
}
trait Changer {
}
}
-fn atol(s: String) -> int {
+fn atol(s: String) -> isize {
let c = CString::new(s).unwrap();
- unsafe { mlibc::atol(c.as_ptr()) as int }
+ unsafe { mlibc::atol(c.as_ptr()) as isize }
}
fn atoll(s: String) -> i64 {
// pretty-expanded FIXME #23616
-fn foo() -> int { 22 }
+fn foo() -> isize { 22 }
pub fn main() {
- let mut x: Vec<extern "Rust" fn() -> int> = Vec::new();
+ let mut x: Vec<extern "Rust" fn() -> isize> = Vec::new();
x.push(foo);
assert_eq!((x[0])(), 22);
}
fn main() {
let mut sum = 0;
let elems = [ 1, 2, 3, 4, 5 ];
- each(&elems, |val: &uint| sum += *val);
+ each(&elems, |val: &usize| sum += *val);
assert_eq!(sum, 15);
}
// issues #10618 and #16382
// pretty-expanded FIXME #23616
-const SIZE: int = 25;
+const SIZE: isize = 25;
fn main() {
- let _a: [bool; 1 as uint];
- let _b: [int; SIZE as uint] = [1; SIZE as uint];
- let _c: [bool; '\n' as uint] = [true; '\n' as uint];
- let _d: [bool; true as uint] = [true; true as uint];
+ let _a: [bool; 1 as usize];
+ let _b: [isize; SIZE as usize] = [1; SIZE as usize];
+ let _c: [bool; '\n' as usize] = [true; '\n' as usize];
+ let _d: [bool; true as usize] = [true; true as usize];
}
// except according to those terms.
pub fn main() {
- let x: int = 3;
- println!("&x={:x}", (&x as *const int as uint));
+ let x: isize = 3;
+ println!("&x={:x}", (&x as *const isize as usize));
}
// pretty-expanded FIXME #23616
pub fn main() {
- let i: int = 'Q' as int;
+ let i: isize = 'Q' as isize;
assert_eq!(i, 0x51);
let u: u32 = i as u32;
assert_eq!(u, 0x51 as u32);
#[derive(Copy)]
struct Foo {
- x: int
+ x: isize
}
impl Clone for Foo {
// pretty-expanded FIXME #23616
#[cfg(all(fooA, not(bar)))]
-fn foo1() -> int { 1 }
+fn foo1() -> isize { 1 }
// !fooA AND !bar
#[cfg(all(not(fooA), not(bar)))]
-fn foo2() -> int { 2 }
+fn foo2() -> isize { 2 }
// fooC OR (fooB AND !bar)
#[cfg(any(fooC, all(fooB, not(bar))))]
-fn foo2() -> int { 3 }
+fn foo2() -> isize { 3 }
// fooA AND bar
#[cfg(all(fooA, bar))]
-fn foo3() -> int { 2 }
+fn foo3() -> isize { 2 }
// !(fooA AND bar)
#[cfg(not(all(fooA, bar)))]
-fn foo3() -> int { 3 }
+fn foo3() -> isize { 3 }
pub fn main() {
assert_eq!(1, foo1());
// pretty-expanded FIXME #23616
-static mut TEST: &'static mut [int] = &mut [1];
+static mut TEST: &'static mut [isize] = &mut [1];
pub fn main() {
unsafe {
// pretty-expanded FIXME #23616
-const aa: [int; 3] = [1, 2, 3];
-const ab: &'static [int; 3] = &aa;
-const ac: &'static [int] = ab;
-const ad: &'static [int] = &aa;
-const ae: &'static [int; 3] = &[1, 2, 3];
-const af: &'static [int] = &[1, 2, 3];
+const aa: [isize; 3] = [1, 2, 3];
+const ab: &'static [isize; 3] = &aa;
+const ac: &'static [isize] = ab;
+const ad: &'static [isize] = &aa;
+const ae: &'static [isize; 3] = &[1, 2, 3];
+const af: &'static [isize] = &[1, 2, 3];
-static ca: int = aa[0];
-static cb: int = ab[1];
-static cc: int = ac[2];
-static cd: int = ad[0];
-static ce: int = ae[1];
-static cf: int = af[2];
+static ca: isize = aa[0];
+static cb: isize = ab[1];
+static cc: isize = ac[2];
+static cd: isize = ad[0];
+static ce: isize = ae[1];
+static cf: isize = af[2];
fn main () {
- let b: &[int] = &[1, 2, 3];
+ let b: &[isize] = &[1, 2, 3];
assert!(ac == b);
assert!(ad == b);
assert!(af == b);
trait noisy {
- fn speak(&mut self) -> int;
+ fn speak(&mut self) -> isize;
}
struct dog {
- barks: uint,
+ barks: usize,
- volume: int,
+ volume: isize,
}
impl dog {
- fn bark(&mut self) -> int {
+ fn bark(&mut self) -> isize {
println!("Woof {} {}", self.barks, self.volume);
self.barks += 1_usize;
if self.barks % 3_usize == 0_usize {
}
impl noisy for dog {
- fn speak(&mut self) -> int {
+ fn speak(&mut self) -> isize {
self.bark()
}
}
#[derive(Clone)]
struct cat {
- meows: uint,
+ meows: usize,
- how_hungry: int,
+ how_hungry: isize,
name: String,
}
impl noisy for cat {
- fn speak(&mut self) -> int {
- self.meow() as int
+ fn speak(&mut self) -> isize {
+ self.meow() as isize
}
}
impl cat {
- pub fn meow_count(&self) -> uint {
+ pub fn meow_count(&self) -> usize {
self.meows
}
}
impl cat {
- fn meow(&mut self) -> uint {
+ fn meow(&mut self) -> usize {
println!("Meow");
self.meows += 1_usize;
if self.meows % 5_usize == 0_usize {
}
}
-fn cat(in_x: uint, in_y: int, in_name: String) -> cat {
+fn cat(in_x: usize, in_y: isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
}
struct cat {
- meows: uint,
- how_hungry: int,
+ meows: usize,
+ how_hungry: isize,
name: String,
}
}
}
-fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
// pretty-expanded FIXME #23616
struct cat {
- done : extern fn(uint),
- meows : uint,
+ done : extern fn(usize),
+ meows : usize,
}
impl Drop for cat {
}
}
-fn cat(done: extern fn(uint)) -> cat {
+fn cat(done: extern fn(usize)) -> cat {
cat {
meows: 0,
done: done
mod kitty {
pub struct cat {
- meows: uint,
+ meows: usize,
name: String,
}
impl cmp::PartialEq for cat_type {
fn eq(&self, other: &cat_type) -> bool {
- ((*self) as uint) == ((*other) as uint)
+ ((*self) as usize) == ((*other) as usize)
}
fn ne(&self, other: &cat_type) -> bool { !(*self).eq(other) }
}
// Very silly -- this just returns the value of the name field
-// for any int value that's less than the meows field
+// for any isize value that's less than the meows field
// ok: T should be in scope when resolving the trait ref for map
struct cat<T> {
// Yes, you can have negative meows
- meows : int,
+ meows : isize,
- how_hungry : int,
+ how_hungry : isize,
name : T,
}
return false;
}
}
- fn len(&self) -> uint { self.meows as uint }
+ fn len(&self) -> usize { self.meows as usize }
fn is_empty(&self) -> bool { self.meows == 0 }
fn clear(&mut self) {}
- fn contains_key(&self, k: &int) -> bool { *k <= self.meows }
+ fn contains_key(&self, k: &isize) -> bool { *k <= self.meows }
- fn find(&self, k: &int) -> Option<&T> {
+ fn find(&self, k: &isize) -> Option<&T> {
if *k <= self.meows {
Some(&self.name)
} else {
None
}
}
- fn insert(&mut self, k: int, _: T) -> bool {
+ fn insert(&mut self, k: isize, _: T) -> bool {
self.meows += k;
true
}
- fn find_mut(&mut self, _k: &int) -> Option<&mut T> { panic!() }
+ fn find_mut(&mut self, _k: &isize) -> Option<&mut T> { panic!() }
- fn remove(&mut self, k: &int) -> bool {
+ fn remove(&mut self, k: &isize) -> bool {
if self.find(k).is_some() {
self.meows -= *k; true
} else {
}
}
- fn pop(&mut self, _k: &int) -> Option<T> { panic!() }
+ fn pop(&mut self, _k: &isize) -> Option<T> { panic!() }
- fn swap(&mut self, _k: int, _v: T) -> Option<T> { panic!() }
+ fn swap(&mut self, _k: isize, _v: T) -> Option<T> { panic!() }
}
impl<T> cat<T> {
- pub fn get(&self, k: &int) -> &T {
+ pub fn get(&self, k: &isize) -> &T {
match self.find(k) {
Some(v) => { v }
None => { panic!("epic fail"); }
}
}
- pub fn new(in_x: int, in_y: int, in_name: T) -> cat<T> {
+ pub fn new(in_x: isize, in_y: isize, in_name: T) -> cat<T> {
cat{meows: in_x, how_hungry: in_y, name: in_name }
}
}
use cci_class_trait::animals::noisy;
struct cat {
- meows: uint,
+ meows: usize,
- how_hungry : int,
+ how_hungry : isize,
name : String,
}
}
}
-fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
#[derive(Clone)]
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
name : String,
}
fn speak(&mut self) { self.meow(); }
}
-fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
// pretty-expanded FIXME #23616
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
}
impl cat {
pub fn speak(&mut self) { self.meows += 1; }
- pub fn meow_count(&mut self) -> uint { self.meows }
+ pub fn meow_count(&mut self) -> usize { self.meows }
}
-fn cat(in_x: uint, in_y: int) -> cat {
+fn cat(in_x: usize, in_y: isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
struct cat<U> {
info : Vec<U> ,
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
}
impl<U> cat<U> {
pub fn speak<T>(&mut self, stuff: Vec<T> ) {
self.meows += stuff.len();
}
- pub fn meow_count(&mut self) -> uint { self.meows }
+ pub fn meow_count(&mut self) -> usize { self.meows }
}
-fn cat<U>(in_x : uint, in_y : int, in_info: Vec<U> ) -> cat<U> {
+fn cat<U>(in_x : usize, in_y : isize, in_info: Vec<U> ) -> cat<U> {
cat {
meows: in_x,
how_hungry: in_y,
}
pub fn main() {
- let mut nyan : cat<int> = cat::<int>(52, 99, vec!(9));
+ let mut nyan : cat<isize> = cat::<isize>(52, 99, vec!(9));
let mut kitty = cat(1000, 2, vec!("tabby".to_string()));
assert_eq!(nyan.how_hungry, 99);
assert_eq!(kitty.how_hungry, 2);
use std::fmt;
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
name : String,
}
}
}
-fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
use std::marker::PhantomData;
struct cat<U> {
- meows : uint,
- how_hungry : int,
+ meows : usize,
+ how_hungry : isize,
m: PhantomData<U>
}
impl<U> cat<U> {
pub fn speak(&mut self) { self.meows += 1; }
- pub fn meow_count(&mut self) -> uint { self.meows }
+ pub fn meow_count(&mut self) -> usize { self.meows }
}
-fn cat<U>(in_x : uint, in_y : int) -> cat<U> {
+fn cat<U>(in_x : usize, in_y : isize) -> cat<U> {
cat {
meows: in_x,
how_hungry: in_y,
pub fn main() {
- let _nyan : cat<int> = cat::<int>(52, 99);
+ let _nyan : cat<isize> = cat::<isize>(52, 99);
// let mut kitty = cat(1000, 2);
}
// pretty-expanded FIXME #23616
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
}
impl cat {
pub fn speak(&mut self) {}
}
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
// pretty-expanded FIXME #23616
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
}
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
// except according to those terms.
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
name : String,
}
}
}
-fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+fn cat(in_x : usize, in_y : isize, in_name: String) -> cat {
cat {
meows: in_x,
how_hungry: in_y,
use std::os;
-struct Test { x: int }
+struct Test { x: isize }
impl Test {
- fn get_x(&self) -> Option<Box<int>> {
+ fn get_x(&self) -> Option<Box<isize>> {
Some(box self.x)
}
}
-fn do_something(t: &Test) -> int {
+fn do_something(t: &Test) -> isize {
// The cleanup scope for the result of `t.get_x()` should be the
// arm itself and not the match, otherwise we'll (potentially) get
struct Temporary;
-static mut DROPPED: int = 0;
+static mut DROPPED: isize = 0;
impl Drop for Temporary {
fn drop(&mut self) {
Bickwick(Foo)
}
-struct Foo { field: Box<uint> }
+struct Foo { field: Box<usize> }
-fn do_it(x: &[uint]) -> Foo {
+fn do_it(x: &[usize]) -> Foo {
panic!()
}
-fn get_bar(x: uint) -> Vec<uint> { vec!(x * 2) }
+fn get_bar(x: usize) -> Vec<usize> { vec!(x * 2) }
pub fn fails() {
let x = 2;
if args.len() >= 2 && args[1] == "signal" {
// Raise a segfault.
- unsafe { *(0 as *mut int) = 0; }
+ unsafe { *(0 as *mut isize) = 0; }
}
}
use std::thread::Thread;
struct Pair {
- a: int,
- b: int
+ a: isize,
+ b: isize
}
pub fn main() {
}
}
-struct Int(int);
+struct Int(isize);
impl PartialEq for Int {
fn eq(&self, other: &Int) -> bool {
}
}
-struct RevInt(int);
+struct RevInt(isize);
impl PartialEq for RevInt {
fn eq(&self, other: &RevInt) -> bool {
// rvalue expressions to be unsized. See #20169 for more information.
pub fn main() {
- // FIXME #22405: We cannot infer the type `Box<[int; k]>` for
- // the r-value expression from the context `Box<[int]>`, and
+ // FIXME #22405: We cannot infer the type `Box<[isize; k]>` for
+ // the r-value expression from the context `Box<[isize]>`, and
// therefore the `box EXPR` desugaring breaks down.
//
// One could reasonably claim that the `box EXPR` desugaring is
// eventually fix that, at which point the `Box::new` calls below
// should be replaced wth uses of `box`.
- let _: Box<[int]> = Box::new({ [1, 2, 3] });
- let _: Box<[int]> = Box::new(if true { [1, 2, 3] } else { [1, 3, 4] });
- let _: Box<[int]> = Box::new(match true { true => [1, 2, 3], false => [1, 3, 4] });
- let _: Box<Fn(int) -> _> = Box::new({ |x| (x as u8) });
+ let _: Box<[isize]> = Box::new({ [1, 2, 3] });
+ let _: Box<[isize]> = Box::new(if true { [1, 2, 3] } else { [1, 3, 4] });
+ let _: Box<[isize]> = Box::new(match true { true => [1, 2, 3], false => [1, 3, 4] });
+ let _: Box<Fn(isize) -> _> = Box::new({ |x| (x as u8) });
let _: Box<Debug> = Box::new(if true { false } else { true });
let _: Box<Debug> = Box::new(match true { true => 'a', false => 'b' });
- let _: &[int] = &{ [1, 2, 3] };
- let _: &[int] = &if true { [1, 2, 3] } else { [1, 3, 4] };
- let _: &[int] = &match true { true => [1, 2, 3], false => [1, 3, 4] };
- let _: &Fn(int) -> _ = &{ |x| (x as u8) };
+ let _: &[isize] = &{ [1, 2, 3] };
+ let _: &[isize] = &if true { [1, 2, 3] } else { [1, 3, 4] };
+ let _: &[isize] = &match true { true => [1, 2, 3], false => [1, 3, 4] };
+ let _: &Fn(isize) -> _ = &{ |x| (x as u8) };
let _: &Debug = &if true { false } else { true };
let _: &Debug = &match true { true => 'a', false => 'b' };
- let _: Box<[int]> = Box::new([1, 2, 3]);
- let _: Box<Fn(int) -> _> = Box::new(|x| (x as u8));
+ let _: Box<[isize]> = Box::new([1, 2, 3]);
+ let _: Box<Fn(isize) -> _> = Box::new(|x| (x as u8));
- let _: Vec<Box<Fn(int) -> _>> = vec![
+ let _: Vec<Box<Fn(isize) -> _>> = vec![
Box::new(|x| (x as u8)),
Box::new(|x| (x as i16 as u8)),
];
use std::boxed::Box;
pub fn main() {
- let _: Box<[int]> = if true { Box::new([1, 2, 3]) } else { Box::new([1]) };
+ let _: Box<[isize]> = if true { Box::new([1, 2, 3]) } else { Box::new([1]) };
- let _: Box<[int]> = match true { true => Box::new([1, 2, 3]), false => Box::new([1]) };
+ let _: Box<[isize]> = match true { true => Box::new([1, 2, 3]), false => Box::new([1]) };
// Check we don't get over-keen at propagating coercions in the case of casts.
let x = if true { 42 } else { 42u8 } as u16;
#![feature(box_syntax)]
pub fn main() {
- let _: Box<[int]> =
+ let _: Box<[isize]> =
if true { let b: Box<_> = box [1, 2, 3]; b } else { let b: Box<_> = box [1]; b };
- let _: Box<[int]> = match true {
+ let _: Box<[isize]> = match true {
true => { let b: Box<_> = box [1, 2, 3]; b }
false => { let b: Box<_> = box [1]; b }
};
// pretty-expanded FIXME #23616
-fn negate(x: &int) -> int {
+fn negate(x: &isize) -> isize {
-*x
}
-fn negate_mut(y: &mut int) -> int {
+fn negate_mut(y: &mut isize) -> isize {
negate(y)
}
-fn negate_imm(y: &int) -> int {
+fn negate_imm(y: &isize) -> isize {
negate(y)
}
// pretty-expanded FIXME #23616
struct SpeechMaker {
- speeches: uint
+ speeches: usize
}
impl SpeechMaker {
- pub fn how_many(&self) -> uint { self.speeches }
+ pub fn how_many(&self) -> usize { self.speeches }
}
-fn foo(speaker: &SpeechMaker) -> uint {
+fn foo(speaker: &SpeechMaker) -> usize {
speaker.how_many() + 33
}
// pretty-expanded FIXME #23616
-fn sum(x: &[int]) -> int {
+fn sum(x: &[isize]) -> isize {
let mut sum = 0;
for y in x { sum += *y; }
return sum;
}
-fn sum_mut(y: &mut [int]) -> int {
+fn sum_mut(y: &mut [isize]) -> isize {
sum(y)
}
-fn sum_imm(y: &[int]) -> int {
+fn sum_imm(y: &[isize]) -> isize {
sum(y)
}
// pretty-expanded FIXME #23616
-fn bar(v: &mut [uint]) -> Vec<uint> {
+fn bar(v: &mut [usize]) -> Vec<usize> {
v.to_vec()
}
-fn bip(v: &[uint]) -> Vec<uint> {
+fn bip(v: &[usize]) -> Vec<usize> {
v.to_vec()
}
// pretty-expanded FIXME #23616
struct SpeechMaker {
- speeches: uint
+ speeches: usize
}
fn talk(x: &mut SpeechMaker) {
// pretty-expanded FIXME #23616
struct SpeechMaker {
- speeches: uint
+ speeches: usize
}
impl SpeechMaker {
// pretty-expanded FIXME #23616
-fn reverse(v: &mut [uint]) {
+fn reverse(v: &mut [usize]) {
v.reverse();
}
-fn bar(v: &mut [uint]) {
+fn bar(v: &mut [usize]) {
reverse(v);
reverse(v);
reverse(v);
// pretty-expanded FIXME #23616
-fn bar(v: &mut [uint]) {
+fn bar(v: &mut [usize]) {
v.reverse();
v.reverse();
v.reverse();
enum x { foo }
impl ::std::cmp::PartialEq for x {
fn eq(&self, other: &x) -> bool {
- (*self) as int == (*other) as int
+ (*self) as isize == (*other) as isize
}
fn ne(&self, other: &x) -> bool { !(*self).eq(other) }
}
// heterogeneous pair.
trait MyTrait {
- fn get(&self) -> uint;
+ fn get(&self) -> usize;
}
impl<T> MyTrait for (T,T) {
- fn get(&self) -> uint { 0 }
+ fn get(&self) -> usize { 0 }
}
-impl MyTrait for (uint,int) {
- fn get(&self) -> uint { 0 }
+impl MyTrait for (usize,isize) {
+ fn get(&self) -> usize { 0 }
}
fn main() {
#[derive(Clone, Copy, Debug, PartialEq)]
struct MyType {
- dummy: uint
+ dummy: usize
}
impl MyTrait for MyType {
assert_eq!(y, 10);
}
-fn child(c: &Sender<int>) {
+fn child(c: &Sender<isize>) {
println!("sending");
c.send(10).unwrap();
println!("value sent");
// pretty-expanded FIXME #23616
-type an_int = int;
+type an_int = isize;
-fn cmp(x: Option<an_int>, y: Option<int>) -> bool {
+fn cmp(x: Option<an_int>, y: Option<isize>) -> bool {
x == y
}
-type t = int;
+type t = isize;
fn nothing() { }
fn putstr(_s: String) { }
-fn putint(_i: int) {
- let mut i: int = 33;
+fn putint(_i: isize) {
+ let mut i: isize = 33;
while i < 36 { putstr("hi".to_string()); i = i + 1; }
}
-fn zerg(i: int) -> int { return i; }
+fn zerg(i: isize) -> isize { return i; }
-fn foo(x: int) -> int {
+fn foo(x: isize) -> isize {
let mut y: t = x + 2;
putstr("hello".to_string());
while y < 10 { putint(y); if y * 3 == 4 { y = y + 2; nothing(); } }
}
pub fn main() {
- let x: int = 2 + 2;
+ let x: isize = 2 + 2;
println!("{}", x);
println!("hello, world");
println!("{}", 10);
}
#[cfg(bogus)]
-type t = int;
+type t = isize;
type t = bool;
#[cfg(bogus)]
struct r {
- i: int,
+ i: isize,
}
#[cfg(bogus)]
-fn r(i:int) -> r {
+fn r(i:isize) -> r {
r {
i: i
}
}
struct r {
- i: int,
+ i: isize,
}
-fn r(i:int) -> r {
+fn r(i:isize) -> r {
r {
i: i
}
f();
#[cfg(bogus)]
- static i: int = 0;
- static i: int = 1;
+ static i: isize = 0;
+ static i: isize = 1;
assert_eq!(i, 1);
}
mod test_methods {
struct Foo {
- bar: uint
+ bar: usize
}
impl Fooable for Foo {
})
}
-static A: int = -4 + 3;
-static A2: uint = 3 + 3;
+static A: isize = -4 + 3;
+static A2: usize = 3 + 3;
static B: f64 = 3.0 + 2.7;
-static C: int = 3 - 4;
-static D: uint = 3 - 3;
+static C: isize = 3 - 4;
+static D: usize = 3 - 3;
static E: f64 = 3.0 - 2.7;
-static E2: int = -3 * 3;
-static F: uint = 3 * 3;
+static E2: isize = -3 * 3;
+static F: usize = 3 * 3;
static G: f64 = 3.3 * 3.3;
-static H: int = 3 / -1;
-static I: uint = 3 / 3;
+static H: isize = 3 / -1;
+static I: usize = 3 / 3;
static J: f64 = 3.3 / 3.3;
static N: bool = true && false;
static O: bool = true || false;
-static P: int = 3 & 1;
-static Q: uint = 1 & 3;
+static P: isize = 3 & 1;
+static Q: usize = 1 & 3;
-static R: int = 3 | 1;
-static S: uint = 1 | 3;
+static R: isize = 3 | 1;
+static S: usize = 1 | 3;
-static T: int = 3 ^ 1;
-static U: uint = 1 ^ 3;
+static T: isize = 3 ^ 1;
+static U: usize = 1 ^ 3;
-static V: int = 1 << 3;
+static V: isize = 1 << 3;
// NOTE: better shr coverage
-static W: int = 1024 >> 4;
-static X: uint = 1024 >> 4;
+static W: isize = 1024 >> 4;
+static X: usize = 1024 >> 4;
static Y: bool = 1 == 1;
static Z: bool = 1.0f64 == 1.0;
struct MyType {
desc: &'static str,
- data: uint,
- code: fn(uint, uint) -> uint
+ data: usize,
+ code: fn(usize, usize) -> usize
}
impl MyType {
- fn eval(&self, a: uint) -> uint {
+ fn eval(&self, a: usize) -> usize {
(self.code)(self.data, a)
}
}
macro_rules! codegen {
($e:expr, $v:expr) => {
{
- fn generated(a: uint, b: uint) -> uint {
+ fn generated(a: usize, b: usize) -> usize {
a - ($e * b)
}
MyType {
mod foo {
pub trait Value {
- fn value(&self) -> uint;
+ fn value(&self) -> usize;
}
}
-static BLOCK_USE: uint = {
+static BLOCK_USE: usize = {
use foo::Value;
100
};
-static BLOCK_PUB_USE: uint = {
+static BLOCK_PUB_USE: usize = {
pub use foo::Value;
200
};
-static BLOCK_STRUCT_DEF: uint = {
+static BLOCK_STRUCT_DEF: usize = {
struct Foo {
- a: uint
+ a: usize
}
Foo{ a: 300 }.a
};
-static BLOCK_FN_DEF: fn(uint) -> uint = {
- fn foo(a: uint) -> uint {
+static BLOCK_FN_DEF: fn(usize) -> usize = {
+ fn foo(a: usize) -> usize {
a + 10
}
foo
};
-static BLOCK_MACRO_RULES: uint = {
+static BLOCK_MACRO_RULES: usize = {
macro_rules! baz {
() => (412)
}
fn foo<T: Sync>(x: T) -> T { x }
-struct F { field: int }
+struct F { field: isize }
pub fn main() {
/*foo(1);
// pretty-expanded FIXME #23616
-const a: int = 1;
-const b: int = a + 2;
+const a: isize = 1;
+const b: isize = a + 2;
pub fn main() {
assert_eq!(b, 3);
// pretty-expanded FIXME #23616
-static lsl : int = 1 << 2;
-static add : int = 1 + 2;
+static lsl : isize = 1 << 2;
+static add : isize = 1 + 2;
static addf : f64 = 1.0 + 2.0;
-static not : int = !0;
+static not : isize = !0;
static notb : bool = !true;
-static neg : int = -(1);
+static neg : isize = -(1);
pub fn main() {
assert_eq!(lsl, 4);
extern crate cci_const;
static foo: &'static str = cci_const::foopy;
-static a: uint = cci_const::uint_val;
-static b: uint = cci_const::uint_expr + 5;
+static a: usize = cci_const::uint_val;
+static b: usize = cci_const::uint_expr + 5;
pub fn main() {
assert_eq!(a, 12);
// pretty-expanded FIXME #23616
-const C: &'static int = &1000;
-static D: int = *C;
+const C: &'static isize = &1000;
+static D: isize = *C;
pub fn main() {
assert_eq!(D, 1000);
// pretty-expanded FIXME #23616
-enum E { V, VV(int) }
+enum E { V, VV(isize) }
static C: E = E::V;
impl E {
// pretty-expanded FIXME #23616
-enum E { V, VV(int) }
+enum E { V, VV(isize) }
static C: E = E::V;
fn f(a: &E) {
enum B { B1=0, B2=2 }
pub fn main () {
- static c1: int = A::A2 as int;
- static c2: int = B::B2 as int;
- let a1 = A::A2 as int;
- let a2 = B::B2 as int;
+ static c1: isize = A::A2 as isize;
+ static c2: isize = B::B2 as isize;
+ let a1 = A::A2 as isize;
+ let a2 = B::B2 as isize;
assert_eq!(c1, 1);
assert_eq!(c2, 2);
assert_eq!(a1, 1);
// pretty-expanded FIXME #23616
-enum E { V0, V1(int) }
+enum E { V0, V1(isize) }
static C: &'static E = &E::V0;
pub fn main() {
enum E {
S0 { s: String },
- S1 { u: uint }
+ S1 { u: usize }
}
static C: E = E::S1 { u: 23 };
// pretty-expanded FIXME #23616
-enum E { V1(int), V0 }
+enum E { V1(isize), V0 }
const C: &'static [E] = &[E::V0, E::V1(0xDEADBEE)];
static C0: E = C[0];
static C1: E = C[1];
// pretty-expanded FIXME #23616
-enum E { V1(int), V0 }
+enum E { V1(isize), V0 }
static C: &'static [E] = &[E::V0, E::V1(0xDEADBEE), E::V0];
pub fn main() {
// pretty-expanded FIXME #23616
-enum E { V1(int), V0 }
+enum E { V1(isize), V0 }
static C: [E; 3] = [E::V0, E::V1(0xDEADBEE), E::V0];
pub fn main() {
pub fn main() {
- const FOO: uint = 2;
- let _v: [int; FOO*3];
+ const FOO: usize = 2;
+ let _v: [isize; FOO*3];
}
pub fn main() {
- const FOO: uint = 2;
+ const FOO: usize = 2;
let _v = [0; FOO*3*2/2];
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-const x : [int; 4] = [1,2,3,4];
-static p : int = x[2];
-const y : &'static [int] = &[1,2,3,4];
-static q : int = y[2];
+const x : [isize; 4] = [1,2,3,4];
+static p : isize = x[2];
+const y : &'static [isize] = &[1,2,3,4];
+static q : isize = y[2];
-struct S {a: int, b: int}
+struct S {a: isize, b: isize}
const s : S = S {a: 10, b: 20};
-static t : int = s.b;
+static t : isize = s.b;
-struct K {a: int, b: int, c: D}
-struct D { d: int, e: int }
+struct K {a: isize, b: isize, c: D}
+struct D { d: isize, e: isize }
const k : K = K {a: 10, b: 20, c: D {d: 30, e: 40}};
-static m : int = k.c.e;
+static m : isize = k.c.e;
pub fn main() {
println!("{}", p);
// pretty-expanded FIXME #23616
-fn foo() -> int {
+fn foo() -> isize {
return 0xca7f000d;
}
-struct Bar<F> where F: FnMut() -> int { f: F }
+struct Bar<F> where F: FnMut() -> isize { f: F }
-static mut b : Bar<fn() -> int> = Bar { f: foo as fn() -> int};
+static mut b : Bar<fn() -> isize> = Bar { f: foo as fn() -> isize};
pub fn main() {
unsafe { assert_eq!((b.f)(), 0xca7f000d); }
// pretty-expanded FIXME #23616
-static toplevel_mod: int = -1;
+static toplevel_mod: isize = -1;
pub fn main() {
assert_eq!(toplevel_mod, -1);
static X: Foo = Foo::Bar;
pub fn main() {
- assert_eq!((X as uint), 0xDEADBEE);
- assert_eq!((Y as uint), 0xDEADBEE);
+ assert_eq!((X as usize), 0xDEADBEE);
+ assert_eq!((Y as usize), 0xDEADBEE);
}
static Y: Foo = Foo::Bar;
// pretty-expanded FIXME #23616
type Big = [u64; 8];
-struct Pair<'a> { a: int, b: &'a Big }
+struct Pair<'a> { a: isize, b: &'a Big }
const x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]);
const y: &'static Pair<'static> = &Pair {a: 15, b: x};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct Pair<'a> { a: int, b: &'a int }
+struct Pair<'a> { a: isize, b: &'a isize }
-const x: &'static int = &10;
+const x: &'static isize = &10;
const y: &'static Pair<'static> = &Pair {a: 15, b: x};
use std::cmp;
#[derive(Debug)]
-struct foo { a: int, b: int, c: int }
+struct foo { a: isize, b: isize, c: isize }
impl cmp::PartialEq for foo {
fn eq(&self, other: &foo) -> bool {
// pretty-expanded FIXME #23616
-struct Bar(int, int);
+struct Bar(isize, isize);
static X: Bar = Bar(1, 2);
// pretty-expanded FIXME #23616
-fn f(_: &[int]) {}
+fn f(_: &[isize]) {}
pub fn main() {
let v = [ 1, 2, 3 ];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-static x : [int; 4] = [1,2,3,4];
-static y : &'static [int] = &[1,2,3,4];
-static z : &'static [int; 4] = &[1,2,3,4];
-static zz : &'static [int] = &[1,2,3,4];
+static x : [isize; 4] = [1,2,3,4];
+static y : &'static [isize] = &[1,2,3,4];
+static z : &'static [isize; 4] = &[1,2,3,4];
+static zz : &'static [isize] = &[1,2,3,4];
pub fn main() {
println!("{}", x[1]);
-static i: int = 10;
+static i: isize = 10;
pub fn main() { println!("{}", i); }
// pretty-expanded FIXME #23616
-const FOO: int = 10;
-const BAR: int = 3;
+const FOO: isize = 10;
+const BAR: isize = 3;
pub fn main() {
- let x: int = 3;
+ let x: isize = 3;
let y = match x {
FOO => 1,
BAR => 2,
fn test_destroy_twice() {
let mut p = sleeper();
- succeed!(p.signal_exit()); // this shouldnt crash...
+ succeed!(p.signal_exit()); // this shouldn't crash...
let _ = p.signal_exit(); // ...and nor should this (and nor should the destructor)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:--crate-name crate-name-attr-used -F unused-attributes
+// compile-flags:--crate-name crate_name_attr_used -F unused-attributes
// pretty-expanded FIXME #23616
-#![crate_name = "crate-name-attr-used"]
+#![crate_name = "crate_name_attr_used"]
fn main() {}
#![deny(dead_code)]
-static _X: uint = 0;
+static _X: usize = 0;
fn _foo() {}
struct _Y {
- _z: uint
+ _z: usize
}
enum _Z {}
fn _bar() {}
}
-type _A = int;
+type _A = isize;
mod _bar {
fn _qux() {}
// pretty-expanded FIXME #23616
-fn f(x: int) -> int {
- if x == 1 { return 1; } else { let y: int = 1 + f(x - 1); return y; }
+fn f(x: isize) -> isize {
+ if x == 1 { return 1; } else { let y: isize = 1 + f(x - 1); return y; }
}
pub fn main() { assert!((f(5000) == 5000)); }
// pretty-expanded FIXME #23616
trait Foo {
- fn m(&self, _:int) { }
+ fn m(&self, _:isize) { }
}
pub fn main() { }
}
struct A {
- x: int
+ x: isize
}
impl Foo for A {
// Tests that we can call a function bounded over a supertrait from
// a default method
-fn require_y<T: Y>(x: T) -> int { x.y() }
+fn require_y<T: Y>(x: T) -> isize { x.y() }
trait Y {
- fn y(self) -> int;
+ fn y(self) -> isize;
}
trait Z: Y + Sized {
- fn x(self) -> int {
+ fn x(self) -> isize {
require_y(self)
}
}
-impl Y for int {
- fn y(self) -> int { self }
+impl Y for isize {
+ fn y(self) -> isize { self }
}
-impl Z for int {}
+impl Z for isize {}
pub fn main() {
assert_eq!(12.x(), 12);
use std::ops::{Deref, DerefMut};
-fn inc<T: Deref<Target=int> + DerefMut>(mut t: T) {
+fn inc<T: Deref<Target=isize> + DerefMut>(mut t: T) {
*t += 1;
}
fn main() {
- let mut x: int = 5;
+ let mut x: isize = 5;
inc(&mut x);
assert_eq!(x, 6);
}
}
fn main() {
- let x: int = 3;
+ let x: isize = 3;
let y = deref(&x);
assert_eq!(y, 3);
- let mut x: int = 4;
+ let mut x: isize = 4;
let y = deref(&mut x);
assert_eq!(y, 4);
}
#![feature(box_syntax)]
pub fn main() {
- let x: Box<int> = box 10;
- let _y: int = *x;
+ let x: Box<isize> = box 10;
+ let _y: isize = *x;
}
extern crate core;
extern crate rand;
-extern crate "serialize" as rustc_serialize;
+extern crate serialize as rustc_serialize;
extern crate collections;
// Issue #16803
}
pub fn main() {
- let _ = E::A::<int, int>(1).clone();
+ let _ = E::A::<isize, isize>(1).clone();
}
#[derive(Clone)]
struct S {
- _int: int,
+ _int: isize,
_i8: i8,
_i16: i16,
_i32: i32,
_i64: i64,
- _uint: uint,
+ _uint: usize,
_u8: u8,
_u16: u16,
_u32: u32,
#[derive(PartialEq,PartialOrd,Eq,Ord)]
struct ShortCircuit {
- x: int,
+ x: isize,
y: FailCmp
}
#[derive(Encodable, Decodable)]
struct A {
- baz: int
+ baz: isize
}
#[derive(Encodable, Decodable)]
#[derive(Encodable, Decodable, Eq, Rand)]
struct A;
#[derive(Encodable, Decodable, Eq, Rand)]
-struct B(int);
+struct B(isize);
#[derive(Encodable, Decodable, Eq, Rand)]
-struct C(int, int, uint);
+struct C(isize, isize, usize);
#[derive(Encodable, Decodable, Eq, Rand)]
struct D {
- a: int,
- b: uint,
+ a: isize,
+ b: usize,
}
#[derive(Encodable, Decodable, Eq, Rand)]
enum E {
E1,
- E2(uint),
+ E2(usize),
E3(D),
- E4{ x: uint },
+ E4{ x: usize },
}
#[derive(Encodable, Decodable, Eq, Rand)]
for _ in 0..20 {
roundtrip::<E>();
roundtrip::<F>();
- roundtrip::<G<int>>();
+ roundtrip::<G<isize>>();
}
}
// pretty-expanded FIXME #23616
-pub type task_id = int;
+pub type task_id = isize;
#[derive(PartialEq)]
pub enum Task {
Clone,
Debug, Rand,
Encodable, Decodable)]
- enum A { A1(uint), A2(int) }
+ enum A { A1(usize), A2(isize) }
#[derive(PartialEq, PartialOrd, Eq, Ord,
Hash,
Clone,
Debug, Rand,
Encodable, Decodable)]
- struct B { x: uint, y: int }
+ struct B { x: usize, y: isize }
#[derive(PartialEq, PartialOrd, Eq, Ord,
Hash,
Clone,
Debug, Rand,
Encodable, Decodable)]
- struct C(uint, int);
+ struct C(usize, isize);
}
#[derive(Hash)]
struct Person {
- id: uint,
+ id: usize,
name: String,
- phone: uint,
+ phone: usize,
}
fn hash<T: Hash>(t: &T) -> u64 {
pub fn main() {
#[derive(Debug)]
struct Foo {
- foo: int,
+ foo: isize,
}
let f = Foo { foo: 10 };
#[derive(Clone)]
#[derive(Hash)]
struct Foo {
- bar: uint,
- baz: int
+ bar: usize,
+ baz: isize
}
fn hash<T: Hash>(_t: &T) {}
#[derive(PartialEq, Clone, Hash)]
struct Foo {
- bar: uint,
- baz: int
+ bar: usize,
+ baz: isize
}
fn hash<T: Hash>(_t: &T) {}
struct A;
#[derive(Rand)]
-struct B(int, int);
+struct B(isize, isize);
#[derive(Rand)]
struct C {
#[derive(Rand)]
enum D {
D0,
- D1(uint),
+ D1(usize),
D2 { x: (), y: () }
}
#[derive(Eq,Ord)]
struct A<'a> {
- x: &'a int
+ x: &'a isize
}
pub fn main() {
let (a, b) = (A { x: &1 }, A { x: &2 });
#[derive(Eq,Ord)]
struct A<'a> {
- x: &'a int
+ x: &'a isize
}
pub fn main() {
#[derive(Debug)]
enum B { B1, B2, B3 }
#[derive(Debug)]
-enum C { C1(int), C2(B), C3(String) }
+enum C { C1(isize), C2(B), C3(String) }
#[derive(Debug)]
-enum D { D1{ a: int } }
+enum D { D1{ a: isize } }
#[derive(Debug)]
struct E;
#[derive(Debug)]
-struct F(int);
+struct F(isize);
#[derive(Debug)]
-struct G(int, int);
+struct G(isize, isize);
#[derive(Debug)]
-struct H { a: int }
+struct H { a: isize }
#[derive(Debug)]
-struct I { a: int, b: int }
+struct I { a: isize, b: isize }
#[derive(Debug)]
struct J(Custom);
struct Unit;
#[derive(Debug)]
-struct Tuple(int, uint);
+struct Tuple(isize, usize);
#[derive(Debug)]
-struct Struct { x: int, y: uint }
+struct Struct { x: isize, y: usize }
#[derive(Debug)]
enum Enum {
Nullary,
- Variant(int, uint),
- StructVariant { x: int, y : uint }
+ Variant(isize, usize),
+ StructVariant { x: isize, y : usize }
}
macro_rules! t {
#[derive(PartialEq, Debug)]
enum Foo {
- Bar(int, int),
+ Bar(isize, isize),
Baz(f64, f64)
}
#[derive(Hash)]
enum Foo {
- Bar(int, char),
- Baz(char, int)
+ Bar(isize, char),
+ Baz(char, isize)
}
#[derive(Hash)]
#[derive(Hash)]
struct Foo {
- x: int,
- y: int,
- z: int
+ x: isize,
+ y: isize,
+ z: isize
}
pub fn main() {}
#[derive(PartialEq, Debug)]
enum S {
- X { x: int, y: int },
+ X { x: isize, y: isize },
Y
}
// except according to those terms.
#[derive(PartialEq, Debug)]
-struct Foo(int, int, String);
+struct Foo(isize, isize, String);
pub fn main() {
let a1 = Foo(5, 6, "abc".to_string());
#[derive(PartialEq, Debug)]
struct Foo {
- x: int,
- y: int,
- z: int,
+ x: isize,
+ y: isize,
+ z: isize,
}
pub fn main() {
#[derive(PartialEq, Hash, Debug)]
struct Foo<T> {
- x: int,
+ x: isize,
y: T,
- z: int
+ z: isize
}
pub fn main() {
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
struct D { x: u8 }
impl Drop for D { fn drop(&mut self) { } }
fn f() {
panic!();
- let _x: int = panic!();
+ let _x: isize = panic!();
}
pub fn main() {
// pretty-expanded FIXME #23616
pub fn main() {
- let x: int = 15;
- let y: int = 5;
+ let x: isize = 15;
+ let y: isize = 5;
assert_eq!(x / 5, 3);
assert_eq!(x / 4, 3);
assert_eq!(x / 3, 5);
// pretty-expanded FIXME #23616
fn check_expr() {
- let _: & uint = &1;
- let _: & & uint = &&1;
- let _: & & & uint = &&&1;
- let _: & & & uint = & &&1;
- let _: & & & & uint = &&&&1;
- let _: & & & & uint = & &&&1;
- let _: & & & & & uint = &&&&&1;
+ let _: & usize = &1;
+ let _: & & usize = &&1;
+ let _: & & & usize = &&&1;
+ let _: & & & usize = & &&1;
+ let _: & & & & usize = &&&&1;
+ let _: & & & & usize = & &&&1;
+ let _: & & & & & usize = &&&&&1;
}
fn check_ty() {
- let _: &uint = & 1;
- let _: &&uint = & & 1;
- let _: &&&uint = & & & 1;
- let _: & &&uint = & & & 1;
- let _: &&&&uint = & & & & 1;
- let _: & &&&uint = & & & & 1;
- let _: &&&&&uint = & & & & & 1;
+ let _: &usize = & 1;
+ let _: &&usize = & & 1;
+ let _: &&&usize = & & & 1;
+ let _: & &&usize = & & & 1;
+ let _: &&&&usize = & & & & 1;
+ let _: & &&&usize = & & & & 1;
+ let _: &&&&&usize = & & & & & 1;
}
fn check_pat() {
--- /dev/null
+// Copyright 2015 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.
+
+// compile-flags: -Z force-dropflag-checks=on
+
+// Quick-and-dirty test to ensure -Z force-dropflag-checks=on works as
+// expected. Note that the inlined drop-flag is slated for removal
+// (RFC 320); when that happens, the -Z flag and this test should
+// simply be removed.
+//
+// See also drop-flag-skip-sanity-check.rs.
+
+#![feature(old_io)]
+
+use std::env;
+use std::old_io::process::{Command, ExitSignal, ExitStatus};
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() > 1 && args[1] == "test" {
+ return test();
+ }
+
+ let mut p = Command::new(&args[0]).arg("test").spawn().unwrap();
+ // The invocation should fail due to the drop-flag sanity check.
+ assert!(!p.wait().unwrap().success());
+}
+
+#[derive(Debug)]
+struct Corrupted {
+ x: u8
+}
+
+impl Drop for Corrupted {
+ fn drop(&mut self) { println!("dropping"); }
+}
+
+fn test() {
+ {
+ let mut c1 = Corrupted { x: 1 };
+ let mut c2 = Corrupted { x: 2 };
+ unsafe {
+ let p1 = &mut c1 as *mut Corrupted as *mut u8;
+ let p2 = &mut c2 as *mut Corrupted as *mut u8;
+ for i in 0..std::mem::size_of::<Corrupted>() {
+ // corrupt everything, *including the drop flag.
+ //
+ // (We corrupt via two different means to safeguard
+ // against the hypothetical assignment of the
+ // dtor_needed/dtor_done values to v and v+k. that
+ // happen to match with one of the corruption values
+ // below.)
+ *p1.offset(i as isize) += 2;
+ *p2.offset(i as isize) += 3;
+ }
+ }
+ // Here, at the end of the scope of `c1` and `c2`, the
+ // drop-glue should detect the corruption of (at least one of)
+ // the drop-flags.
+ }
+ println!("We should never get here.");
+}
--- /dev/null
+// Copyright 2015 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.
+
+// compile-flags: -Z force-dropflag-checks=off
+
+// Quick-and-dirty test to ensure -Z force-dropflag-checks=off works as
+// expected. Note that the inlined drop-flag is slated for removal
+// (RFC 320); when that happens, the -Z flag and this test should
+// simply be removed.
+//
+// See also drop-flag-sanity-check.rs.
+
+#![feature(old_io)]
+
+use std::env;
+use std::old_io::process::{Command, ExitSignal, ExitStatus};
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() > 1 && args[1] == "test" {
+ return test();
+ }
+
+ let mut p = Command::new(&args[0]).arg("test").spawn().unwrap();
+ // Invocatinn should succeed as drop-flag sanity check is skipped.
+ assert!(p.wait().unwrap().success());
+}
+
+#[derive(Debug)]
+struct Corrupted {
+ x: u8
+}
+
+impl Drop for Corrupted {
+ fn drop(&mut self) { println!("dropping"); }
+}
+
+fn test() {
+ {
+ let mut c1 = Corrupted { x: 1 };
+ let mut c2 = Corrupted { x: 2 };
+ unsafe {
+ let p1 = &mut c1 as *mut Corrupted as *mut u8;
+ let p2 = &mut c2 as *mut Corrupted as *mut u8;
+ for i in 0..std::mem::size_of::<Corrupted>() {
+ // corrupt everything, *including the drop flag.
+ //
+ // (We corrupt via two different means to safeguard
+ // against the hypothetical assignment of the
+ // dtor_needed/dtor_done values to v and v+k. that
+ // happen to match with one of the corruption values
+ // below.)
+ *p1.offset(i as isize) += 2;
+ *p2.offset(i as isize) += 3;
+ }
+ }
+ // Here, at the end of the scope of `c1` and `c2`, the
+ // drop-glue should detect the corruption of (at least one of)
+ // the drop-flags.
+ }
+ println!("We should never get here.");
+}
#![allow(unknown_features)]
#![feature(box_syntax)]
-enum t { foo(Box<int>), }
+enum t { foo(Box<isize>), }
pub fn main() {
let tt = t::foo(box 10);
// pretty-expanded FIXME #23616
-fn f() -> int {
+fn f() -> isize {
if true {
let _s: String = "should not leak".to_string();
return 1;
#![allow(unknown_features)]
#![feature(box_syntax)]
-static mut value: uint = 0;
+static mut value: usize = 0;
struct Cat {
- name : uint,
+ name : usize,
}
trait Dummy {
- fn get(&self) -> uint;
+ fn get(&self) -> usize;
}
impl Dummy for Cat {
- fn get(&self) -> uint { self.name }
+ fn get(&self) -> usize { self.name }
}
impl Drop for Cat {
enum Foo {
SimpleVariant(Sender<Message>),
- NestedVariant(Box<uint>, SendOnDrop, Sender<Message>),
+ NestedVariant(Box<usize>, SendOnDrop, Sender<Message>),
FailingVariant { on_drop: SendOnDrop }
}
// except according to those terms.
struct Foo {
- x: int
+ x: isize
}
impl Drop for Foo {
use std::ops::{Deref, DerefMut};
pub struct Arr {
- ptr: Box<[uint]>
+ ptr: Box<[usize]>
}
impl Deref for Arr {
- type Target = [uint];
+ type Target = [usize];
- fn deref(&self) -> &[uint] {
+ fn deref(&self) -> &[usize] {
panic!();
}
}
impl DerefMut for Arr {
- fn deref_mut(&mut self) -> &mut [uint] {
+ fn deref_mut(&mut self) -> &mut [usize] {
&mut *self.ptr
}
}
pub fn foo(arr: &mut Arr) {
- let x: &mut [uint] = &mut **arr;
+ let x: &mut [usize] = &mut **arr;
assert!(x[0] == 1);
assert!(x[1] == 2);
assert!(x[2] == 3);
use std::ops::Deref;
pub struct Arr {
- ptr: Box<[uint]>
+ ptr: Box<[usize]>
}
impl Deref for Arr {
- type Target = [uint];
+ type Target = [usize];
- fn deref(&self) -> &[uint] {
+ fn deref(&self) -> &[usize] {
&*self.ptr
}
}
pub fn foo(arr: &Arr) {
assert!(arr.len() == 3);
- let x: &[uint] = &**arr;
+ let x: &[usize] = &**arr;
assert!(x[0] == 1);
assert!(x[1] == 2);
assert!(x[2] == 3);
struct S;
-impl Index<uint> for S {
+impl Index<usize> for S {
type Output = str;
- fn index<'a>(&'a self, _: uint) -> &'a str {
+ fn index<'a>(&'a self, _: usize) -> &'a str {
"hello"
}
}
struct T;
-impl Index<uint> for T {
+impl Index<usize> for T {
type Output = Debug + 'static;
- fn index<'a>(&'a self, idx: uint) -> &'a (Debug + 'static) {
- static X: uint = 42;
+ fn index<'a>(&'a self, idx: usize) -> &'a (Debug + 'static) {
+ static X: usize = 42;
&X as &(Debug + 'static)
}
}
// pretty-expanded FIXME #23616
trait Trait {
- fn foo(&self) -> int;
+ fn foo(&self) -> isize;
}
struct A {
- f: int
+ f: isize
}
impl Trait for A {
- fn foo(&self) -> int {
+ fn foo(&self) -> isize {
self.f
}
}
}
// raw slice with explicit cast
- let a = &[1, 2, 3] as *const [_];
+ let a = &[1, 2, 3] as *const [i32];
unsafe {
let b = (*a)[2];
assert!(b == 3);
assert!(len == 3);
}
- let a = &mut [1, 2, 3] as *mut [_];
+ let a = &mut [1, 2, 3] as *mut [i32];
unsafe {
let b = (*a)[2];
assert!(b == 3);
}
// x is a fat pointer
-fn foo(x: &Fat<[int]>) {
+fn foo(x: &Fat<[isize]>) {
let y = &x.ptr;
assert!(x.ptr.len() == 3);
assert!(y[0] == 1);
foo(&f1);
let f2 = &f1;
foo(f2);
- let f3: &Fat<[int]> = f2;
+ let f3: &Fat<[isize]> = f2;
foo(f3);
- let f4: &Fat<[int]> = &f1;
+ let f4: &Fat<[isize]> = &f1;
foo(f4);
- let f5: &Fat<[int]> = &Fat { ptr: [1, 2, 3] };
+ let f5: &Fat<[isize]> = &Fat { ptr: [1, 2, 3] };
foo(f5);
// With a vec of Bars.
foo2(f5);
// Assignment.
- let f5: &mut Fat<[int]> = &mut Fat { ptr: [1, 2, 3] };
+ let f5: &mut Fat<[isize]> = &mut Fat { ptr: [1, 2, 3] };
f5.ptr[1] = 34;
assert!(f5.ptr[0] == 1);
assert!(f5.ptr[1] == 34);
assert!(f5.ptr[2] == 3);
// Zero size vec.
- let f5: &Fat<[int]> = &Fat { ptr: [] };
+ let f5: &Fat<[isize]> = &Fat { ptr: [] };
assert!(f5.ptr.len() == 0);
let f5: &Fat<[Bar]> = &Fat { ptr: [] };
assert!(f5.ptr.len() == 0);
#![feature(box_syntax)]
struct Fat<T: ?Sized> {
- f1: int,
+ f1: isize,
f2: &'static str,
ptr: T
}
// x is a fat pointer
-fn foo(x: &Fat<[int]>) {
+fn foo(x: &Fat<[isize]>) {
let y = &x.ptr;
assert!(x.ptr.len() == 3);
assert!(y[0] == 1);
assert!(x.f2 == "some str");
}
-fn foo3(x: &Fat<Fat<[int]>>) {
+fn foo3(x: &Fat<Fat<[isize]>>) {
let y = &x.ptr.ptr;
assert!(x.f1 == 5);
assert!(x.f2 == "some str");
foo(&f1);
let f2 = &f1;
foo(f2);
- let f3: &Fat<[int]> = f2;
+ let f3: &Fat<[isize]> = f2;
foo(f3);
- let f4: &Fat<[int]> = &f1;
+ let f4: &Fat<[isize]> = &f1;
foo(f4);
- let f5: &Fat<[int]> = &Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+ let f5: &Fat<[isize]> = &Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
foo(f5);
// With a vec of Bars.
foo2(f5);
// Assignment.
- let f5: &mut Fat<[int]> = &mut Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+ let f5: &mut Fat<[isize]> = &mut Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
f5.ptr[1] = 34;
assert!(f5.ptr[0] == 1);
assert!(f5.ptr[1] == 34);
assert!(f5.ptr[2] == 3);
// Zero size vec.
- let f5: &Fat<[int]> = &Fat { f1: 5, f2: "some str", ptr: [] };
+ let f5: &Fat<[isize]> = &Fat { f1: 5, f2: "some str", ptr: [] };
assert!(f5.ptr.len() == 0);
let f5: &Fat<[Bar]> = &Fat { f1: 5, f2: "some str", ptr: [] };
assert!(f5.ptr.len() == 0);
foo3(&f1);
let f2 = &f1;
foo3(f2);
- let f3: &Fat<Fat<[int]>> = f2;
+ let f3: &Fat<Fat<[isize]>> = f2;
foo3(f3);
- let f4: &Fat<Fat<[int]>> = &f1;
+ let f4: &Fat<Fat<[isize]>> = &f1;
foo3(f4);
- let f5: &Fat<Fat<[int]>> =
+ let f5: &Fat<Fat<[isize]>> =
&Fat { f1: 5, f2: "some str", ptr: Fat { f1: 8, f2: "deep str", ptr: [1, 2, 3]} };
foo3(f5);
// Box.
let f1 = Box::new([1, 2, 3]);
assert!((*f1)[1] == 2);
- let f2: Box<[int]> = f1;
+ let f2: Box<[isize]> = f1;
assert!((*f2)[1] == 2);
// Nested Box.
- let f1 : Box<Fat<[int; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+ let f1 : Box<Fat<[isize; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
foo(&*f1);
- let f2 : Box<Fat<[int]>> = f1;
+ let f2 : Box<Fat<[isize]>> = f1;
foo(&*f2);
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
- let f3 : Box<Fat<[int]>> =
+ let f3 : Box<Fat<[isize]>> =
Box::<Fat<[_; 3]>>::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
foo(&*f3);
}
#![feature(box_syntax)]
struct Fat<T: ?Sized> {
- f1: int,
+ f1: isize,
f2: &'static str,
ptr: T
}
#[derive(Copy, PartialEq, Eq)]
struct Bar1 {
- f: int
+ f: isize
}
trait ToBar {
fn to_bar(&self) -> Bar;
- fn to_val(&self) -> int;
+ fn to_val(&self) -> isize;
}
impl ToBar for Bar {
fn to_bar(&self) -> Bar {
*self
}
- fn to_val(&self) -> int {
+ fn to_val(&self) -> isize {
0
}
}
fn to_bar(&self) -> Bar {
Bar
}
- fn to_val(&self) -> int {
+ fn to_val(&self) -> isize {
self.f
}
}
// pretty-expanded FIXME #23616
-fn wsucc(n: int) -> int { 0 + { return n + 1 } }
+use std::num::Int;
+
+fn wsucc<T:Int>(n: T) -> T { n + { return n } }
+
pub fn main() { }
trait thing<A> {
fn foo(&self) -> Option<A>;
}
-impl<A> thing<A> for int {
+impl<A> thing<A> for isize {
fn foo(&self) -> Option<A> { None }
}
fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
-struct A { a: int }
+struct A { a: isize }
pub fn main() {
let _x: Option<f64> = foo_func(0);
#![allow(unused_mut)]
-pub fn main() { let mut _v: Vec<int> = Vec::new(); }
+pub fn main() { let mut _v: Vec<isize> = Vec::new(); }
impl PartialEq for chan {
fn eq(&self, other: &chan) -> bool {
- ((*self) as uint) == ((*other) as uint)
+ ((*self) as usize) == ((*other) as usize)
}
fn ne(&self, other: &chan) -> bool { !(*self).eq(other) }
}
use std::mem;
-fn addr_of<T>(ptr: &T) -> uint {
- ptr as *const T as uint
+fn addr_of<T>(ptr: &T) -> usize {
+ ptr as *const T as usize
}
fn is_aligned<T>(ptr: &T) -> bool {
unsafe {
- let addr: uint = mem::transmute(ptr);
+ let addr: usize = mem::transmute(ptr);
(addr % mem::min_align_of::<T>()) == 0
}
}
}
#[inline(never)]
-extern "C" fn foo(_x: uint) -> Foo { Foo::B }
+extern "C" fn foo(_x: usize) -> Foo { Foo::B }
pub fn main() {
unsafe {
- let f: extern "C" fn(uint) -> u32 = ::std::mem::transmute(foo);
+ let f: extern "C" fn(usize) -> u32 = ::std::mem::transmute(foo);
assert_eq!(f(0xDEADBEEF), Foo::B as u32);
}
}
pub fn main() {
let pet: Animal = Animal::Snake;
let hero: Hero = Hero::Superman;
- assert!(pet as uint == 3);
- assert!(hero as int == -2);
+ assert!(pet as usize == 3);
+ assert!(hero as isize == -2);
}
Bu64 = 1
}
-#[repr(int)]
+#[repr(isize)]
enum Eint {
Aint = 0,
Bint = 1
}
-#[repr(uint)]
+#[repr(usize)]
enum Euint {
Auint = 0,
Buint = 1
assert_eq!(size_of::<Eu32>(), 4);
assert_eq!(size_of::<Ei64>(), 8);
assert_eq!(size_of::<Eu64>(), 8);
- assert_eq!(size_of::<Eint>(), size_of::<int>());
- assert_eq!(size_of::<Euint>(), size_of::<uint>());
+ assert_eq!(size_of::<Eint>(), size_of::<isize>());
+ assert_eq!(size_of::<Euint>(), size_of::<usize>());
}
test_color(color::imaginary, -1, "imaginary".to_string());
}
-fn test_color(color: color, val: int, _name: String) {
- assert!(color as int == val);
+fn test_color(color: color, val: isize, _name: String) {
+ assert!(color as isize == val);
}
fn main() {
// Functions
- assert_eq!(size_of::<fn(int)>(), size_of::<Option<fn(int)>>());
- assert_eq!(size_of::<extern "C" fn(int)>(), size_of::<Option<extern "C" fn(int)>>());
+ assert_eq!(size_of::<fn(isize)>(), size_of::<Option<fn(isize)>>());
+ assert_eq!(size_of::<extern "C" fn(isize)>(), size_of::<Option<extern "C" fn(isize)>>());
// Slices - &str / &[T] / &mut [T]
assert_eq!(size_of::<&str>(), size_of::<Option<&str>>());
- assert_eq!(size_of::<&[int]>(), size_of::<Option<&[int]>>());
- assert_eq!(size_of::<&mut [int]>(), size_of::<Option<&mut [int]>>());
+ assert_eq!(size_of::<&[isize]>(), size_of::<Option<&[isize]>>());
+ assert_eq!(size_of::<&mut [isize]>(), size_of::<Option<&mut [isize]>>());
// Traits - Box<Trait> / &Trait / &mut Trait
assert_eq!(size_of::<Box<Trait>>(), size_of::<Option<Box<Trait>>>());
assert_eq!(size_of::<&mut Trait>(), size_of::<Option<&mut Trait>>());
// Pointers - Box<T>
- assert_eq!(size_of::<Box<int>>(), size_of::<Option<Box<int>>>());
+ assert_eq!(size_of::<Box<isize>>(), size_of::<Option<Box<isize>>>());
// The optimization can't apply to raw pointers
- assert!(size_of::<Option<*const int>>() != size_of::<*const int>());
- assert!(Some(0 as *const int).is_some()); // Can't collapse None to null
+ assert!(size_of::<Option<*const isize>>() != size_of::<*const isize>());
+ assert!(Some(0 as *const isize).is_some()); // Can't collapse None to null
struct Foo {
- _a: Box<int>
+ _a: Box<isize>
}
- struct Bar(Box<int>);
+ struct Bar(Box<isize>);
// Should apply through structs
assert_eq!(size_of::<Foo>(), size_of::<Option<Foo>>());
assert_eq!(size_of::<Bar>(), size_of::<Option<Bar>>());
// and tuples
- assert_eq!(size_of::<(u8, Box<int>)>(), size_of::<Option<(u8, Box<int>)>>());
+ assert_eq!(size_of::<(u8, Box<isize>)>(), size_of::<Option<(u8, Box<isize>)>>());
// and fixed-size arrays
- assert_eq!(size_of::<[Box<int>; 1]>(), size_of::<Option<[Box<int>; 1]>>());
+ assert_eq!(size_of::<[Box<isize>; 1]>(), size_of::<Option<[Box<isize>; 1]>>());
// Should apply to NonZero
- assert_eq!(size_of::<NonZero<uint>>(), size_of::<Option<NonZero<uint>>>());
+ assert_eq!(size_of::<NonZero<usize>>(), size_of::<Option<NonZero<usize>>>());
assert_eq!(size_of::<NonZero<*mut i8>>(), size_of::<Option<NonZero<*mut i8>>>());
// Should apply to types that use NonZero internally
- assert_eq!(size_of::<Vec<int>>(), size_of::<Option<Vec<int>>>());
- assert_eq!(size_of::<Arc<int>>(), size_of::<Option<Arc<int>>>());
- assert_eq!(size_of::<Rc<int>>(), size_of::<Option<Rc<int>>>());
+ assert_eq!(size_of::<Vec<isize>>(), size_of::<Option<Vec<isize>>>());
+ assert_eq!(size_of::<Arc<isize>>(), size_of::<Option<Arc<isize>>>());
+ assert_eq!(size_of::<Rc<isize>>(), size_of::<Option<Rc<isize>>>());
// Should apply to types that have NonZero transitively
assert_eq!(size_of::<String>(), size_of::<Option<String>>());
use std::result::Result;
use std::result::Result::Ok;
-static C: Result<(), Box<int>> = Ok(());
+static C: Result<(), Box<isize>> = Ok(());
// This is because of yet another bad assertion (ICE) about the null side of a nullable enum.
// So we won't actually compile if the bug is present, but we check the value in main anyway.
enum Enum2 { A, B, C }
-enum Enum3 { D(int), E, F }
+enum Enum3 { D(isize), E, F }
-enum Enum4 { H(int), I(int), J }
+enum Enum4 { H(isize), I(isize), J }
enum Enum5 { //~ ERROR three times larger
- L(int, int, int, int), //~ NOTE this variant is the largest
- M(int),
+ L(isize, isize, isize, isize), //~ NOTE this variant is the largest
+ M(isize),
N
}
enum Enum6<T, U> {
O(T),
P(U),
- Q(int)
+ Q(isize)
}
#[allow(enum_size_variance)]
enum Enum7 {
- R(int, int, int, int),
- S(int),
+ R(isize, isize, isize, isize),
+ S(isize),
T
}
pub fn main() { }
Bunny = 2
}
-const BAR:uint = Flopsy::Bunny as uint;
-const BAR2:uint = BAR;
+const BAR:usize = Flopsy::Bunny as usize;
+const BAR2:usize = BAR;
pub fn main() {
- let _v = [0; Flopsy::Bunny as uint];
+ let _v = [0; Flopsy::Bunny as usize];
let _v = [0; BAR];
let _v = [0; BAR2];
- const BAR3:uint = BAR2;
+ const BAR3:usize = BAR2;
let _v = [0; BAR3];
}
// Doesn't work; needs a design decision.
pub fn main() {
- let x : [int; 5] = [1,2,3,4,5];
- let _y : [int; 5] = [1,2,3,4,5];
+ let x : [isize; 5] = [1,2,3,4,5];
+ let _y : [isize; 5] = [1,2,3,4,5];
let mut z = [1,2,3,4,5];
z = x;
assert_eq!(z[0], 1);
assert_eq!(z[4], 5);
- let a : [int; 5] = [1,1,1,1,1];
- let b : [int; 5] = [2,2,2,2,2];
- let c : [int; 5] = [2,2,2,2,3];
+ let a : [isize; 5] = [1,1,1,1,1];
+ let b : [isize; 5] = [2,2,2,2,2];
+ let c : [isize; 5] = [2,2,2,2,3];
log(debug, a);
#![allow(dead_assignment)]
pub fn main() {
- let x : &[int] = &[1,2,3,4,5];
- let mut z : &[int] = &[1,2,3,4,5];
+ let x : &[isize] = &[1,2,3,4,5];
+ let mut z : &[isize] = &[1,2,3,4,5];
z = x;
assert_eq!(z[0], 1);
assert_eq!(z[4], 5);
- let a : &[int] = &[1,1,1,1,1];
- let b : &[int] = &[2,2,2,2,2];
- let c : &[int] = &[2,2,2,2,3];
- let cc : &[int] = &[2,2,2,2,2,2];
+ let a : &[isize] = &[1,1,1,1,1];
+ let b : &[isize] = &[2,2,2,2,2];
+ let c : &[isize] = &[2,2,2,2,3];
+ let cc : &[isize] = &[2,2,2,2,2,2];
println!("{:?}", a);
// pretty-expanded FIXME #23616
pub fn main() {
- let x: int = 8;
+ let x: isize = 8;
let y = 9;
x + y;
- let q: int = -8;
+ let q: isize = -8;
let r = -9;
q + r;
}
// pretty-expanded FIXME #23616
struct Box {
- x: uint
+ x: usize
}
impl Box {
- pub fn set_many(&mut self, xs: &[uint]) {
+ pub fn set_many(&mut self, xs: &[usize]) {
for x in xs { self.x = *x; }
}
}
#![feature(box_syntax)]
#[derive(Copy)]
-struct LM { resize_at: uint, size: uint }
+struct LM { resize_at: usize, size: usize }
enum HashMap<K,V> {
HashMap_(LM, Vec<(K,V)>)
}
impl<K,V> HashMap<K,V> {
- pub fn len(&mut self) -> uint {
+ pub fn len(&mut self) -> usize {
match *self {
HashMap::HashMap_(ref l, _) => l.size
}
}
struct S {
- x: int
+ x: isize
}
impl Foo for S {
#[derive(Clone)]
struct A {
- a: int
+ a: isize
}
fn thing(x: A) -> thing {
}
impl thing {
- pub fn bar(self: Box<thing>) -> int { self.x.a }
- pub fn quux(&self) -> int { self.x.a }
+ pub fn bar(self: Box<thing>) -> isize { self.x.a }
+ pub fn quux(&self) -> isize { self.x.a }
pub fn baz<'a>(&'a self) -> &'a A { &self.x }
- pub fn spam(self) -> int { self.x.a }
+ pub fn spam(self) -> isize { self.x.a }
}
trait Nus { fn f(&self); }
mod foo {
use foo::bar::*;
pub mod bar {
- pub static a : int = 10;
+ pub static a : isize = 10;
}
pub fn zum() {
let _b = a;
// pretty-expanded FIXME #23616
fn test_fn() {
- fn ten() -> int { return 10; }
+ fn ten() -> isize { return 10; }
let rs = ten;
assert!((rs() == 10));
}
}
fn test_vec() {
- fn compare_vec(v1: Box<int>, v2: Box<int>) -> bool { return v1 == v2; }
- test_generic::<Box<int>, _>(box 1, compare_vec);
+ fn compare_vec(v1: Box<isize>, v2: Box<isize>) -> bool { return v1 == v2; }
+ test_generic::<Box<isize>, _>(box 1, compare_vec);
}
pub fn main() { test_vec(); }
#[derive(Clone)]
struct Pair {
- a: int,
- b: int,
+ a: isize,
+ b: isize,
}
fn test_rec() {
// pretty-expanded FIXME #23616
-struct A { a: int }
-struct V { v: int }
+struct A { a: isize }
+struct V { v: isize }
pub fn main() {
let a = { let b = A {a: 3}; b };
fn test_basic() { let rs: bool = { true }; assert!((rs)); }
-struct RS { v1: int, v2: int }
+struct RS { v1: isize, v2: isize }
fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); }
}
#[derive(Copy)]
-struct A { a: int }
+struct A { a: isize }
pub fn main() {
let mut x = A {a: 10};
// pretty-expanded FIXME #23616
fn test_int() {
- fn f() -> int { 10 }
+ fn f() -> isize { 10 }
assert_eq!(f(), 10);
}
fn test_vec() {
- fn f() -> Vec<int> { vec!(10, 11) }
+ fn f() -> Vec<isize> { vec!(10, 11) }
let vect = f();
assert_eq!(vect[1], 11);
}
}
fn test_alt() {
- fn f() -> int { match true { false => { 10 } true => { 20 } } }
+ fn f() -> isize { match true { false => { 10 } true => { 20 } } }
assert_eq!(f(), 20);
}
fn test_if() {
- fn f() -> int { if true { 10 } else { 20 } }
+ fn f() -> isize { if true { 10 } else { 20 } }
assert_eq!(f(), 10);
}
fn test_block() {
- fn f() -> int { { 10 } }
+ fn f() -> isize { { 10 } }
assert_eq!(f(), 10);
}
fn test_ret() {
- fn f() -> int {
+ fn f() -> isize {
return 10 // no semi
}
// From issue #372
fn test_372() {
- fn f() -> int { let x = { 3 }; x }
+ fn f() -> isize { let x = { 3 }; x }
assert_eq!(f(), 3);
}
#[derive(Clone)]
struct Pair {
- a: int,
- b: int,
+ a: isize,
+ b: isize,
}
fn test_rec() {
// Tests for if as expressions returning nominal types
#[derive(Copy)]
-struct I { i: int }
+struct I { i: isize }
fn test_rec() {
let rs = if true { I {i: 100} } else { I {i: 101} };
impl PartialEq for mood {
fn eq(&self, other: &mood) -> bool {
- ((*self) as uint) == ((*other) as uint)
+ ((*self) as usize) == ((*other) as usize)
}
fn ne(&self, other: &mood) -> bool { !(*self).eq(other) }
}
}
fn test_vec() {
- fn compare_box(v1: Box<int>, v2: Box<int>) -> bool { return v1 == v2; }
- test_generic::<Box<int>, _>(box 1, compare_box);
+ fn compare_box(v1: Box<isize>, v2: Box<isize>) -> bool { return v1 == v2; }
+ test_generic::<Box<isize>, _>(box 1, compare_box);
}
pub fn main() { test_vec(); }
#[derive(Clone)]
struct Pair {
- a: int,
- b: int,
+ a: isize,
+ b: isize,
}
fn test_rec() {
// Tests for match as expressions resulting in struct types
#[derive(Copy)]
-struct R { i: int }
+struct R { i: isize }
fn test_rec() {
let rs = match true { true => R {i: 100}, _ => panic!() };
impl PartialEq for mood {
fn eq(&self, other: &mood) -> bool {
- ((*self) as uint) == ((*other) as uint)
+ ((*self) as usize) == ((*other) as usize)
}
fn ne(&self, other: &mood) -> bool { !(*self).eq(other) }
}
use std::cell::Cell;
#[derive(Copy)]
-struct Point {x: int, y: int, z: int}
+struct Point {x: isize, y: isize, z: isize}
fn f(p: &Cell<Point>) {
assert!((p.get().z == 12));
// pretty-expanded FIXME #23616
-extern fn f(x: uint) -> uint { x * 2 }
+extern fn f(x: usize) -> usize { x * 2 }
pub fn main() {
let x = f(22);
extern fn voidret1() {}
extern fn voidret2() {}
-extern fn uintret() -> uint { 22 }
+extern fn uintret() -> usize { 22 }
-extern fn uintvoidret(_x: uint) {}
+extern fn uintvoidret(_x: usize) {}
-extern fn uintuintuintuintret(x: uint, y: uint, z: uint) -> uint { x+y+z }
-type uintuintuintuintret = extern fn(uint,uint,uint) -> uint;
+extern fn uintuintuintuintret(x: usize, y: usize, z: usize) -> usize { x+y+z }
+type uintuintuintuintret = extern fn(usize,usize,usize) -> usize;
pub fn main() {
assert!(voidret1 as extern fn() == voidret1 as extern fn());
assert!(voidret1 as extern fn() != voidret2 as extern fn());
- assert!(uintret as extern fn() -> uint == uintret as extern fn() -> uint);
+ assert!(uintret as extern fn() -> usize == uintret as extern fn() -> usize);
- assert!(uintvoidret as extern fn(uint) == uintvoidret as extern fn(uint));
+ assert!(uintvoidret as extern fn(usize) == uintvoidret as extern fn(usize));
assert!(uintuintuintuintret as uintuintuintuintret ==
uintuintuintuintret as uintuintuintuintret);
// pretty-expanded FIXME #23616
-extern crate "std" as mystd;
+extern crate std as mystd;
pub fn main() {}
-fn f(x: int) -> int {
+fn f(x: isize) -> isize {
// println!("in f:");
println!("{}", x);
} else {
// println!("recurring");
- let y: int = x * f(x - 1);
+ let y: isize = x * f(x - 1);
// println!("returned");
println!("{}", y);
}
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
impl Point {
- fn get(&mut self) -> (int, int) {
+ fn get(&mut self) -> (isize, isize) {
(self.x, self.y)
}
}
// pretty-expanded FIXME #23616
-fn f(i: int, called: &mut bool) {
+fn f(i: isize, called: &mut bool) {
assert_eq!(i, 10);
*called = true;
}
-fn g(f: fn(int, v: &mut bool), called: &mut bool) {
+fn g(f: fn(isize, v: &mut bool), called: &mut bool) {
f(10, called);
}
pub fn main() {
// Bare functions should just be a pointer
- assert_eq!(mem::size_of::<extern "Rust" fn()>(), mem::size_of::<int>());
+ assert_eq!(mem::size_of::<extern "Rust" fn()>(), mem::size_of::<isize>());
}
f(val);
}
-fn f(i: int) {
+fn f(i: isize) {
assert_eq!(i, 100);
}
// pretty-expanded FIXME #23616
-fn foo(x: int) -> int { x * 2 }
-fn bar(x: int) -> int { x * 4 }
-type IntMap = fn(int) -> int;
+fn foo(x: isize) -> isize { x * 2 }
+fn bar(x: isize) -> isize { x * 4 }
+type IntMap = fn(isize) -> isize;
fn eq<T>(x: T, y: T) { }
// pretty-expanded FIXME #23616
-fn foo(x: int) -> int { x * 2 }
-fn bar(x: int) -> int { x * 4 }
-type IntMap = fn(int) -> int;
+fn foo(x: isize) -> isize { x * 2 }
+fn bar(x: isize) -> isize { x * 4 }
+type IntMap = fn(isize) -> isize;
fn eq<T>(x: T, y: T) { }
// pretty-expanded FIXME #23616
-fn foo(_f: fn(int) -> int) { }
+fn foo(_f: fn(isize) -> isize) { }
-fn id(x: int) -> int { return x; }
+fn id(x: isize) -> isize { return x; }
pub fn main() { foo(id); }
// except according to those terms.
pub fn main() {
- let v : &[(int,int)] = &[ (1, 2), (3, 4), (5, 6) ];
+ let v : &[(isize,isize)] = &[ (1, 2), (3, 4), (5, 6) ];
for &(x, y) in v {
println!("{}", y);
println!("{}", x);
// pretty-expanded FIXME #23616
pub fn main() {
- let f = |(x, y): (int, int)| {
+ let f = |(x, y): (isize, isize)| {
assert_eq!(x, 1);
assert_eq!(y, 2);
};
// pretty-expanded FIXME #23616
-struct Pair { x: int, y: int }
+struct Pair { x: isize, y: isize }
pub fn main() {
for elt in &(vec!(Pair {x: 10, y: 20}, Pair {x: 30, y: 0})) {
Some(T),
}
-type Iterator = int;
+type Iterator = isize;
pub fn main() {
let x = [ 3, 3, 3 ];
#![feature(lang_items, start, no_std, core, collections)]
#![no_std]
-extern crate "std" as other;
+extern crate std as other;
#[macro_use] extern crate core;
#[macro_use] extern crate collections;
use core::slice::SliceExt;
#[start]
-fn start(_argc: int, _argv: *const *const u8) -> int {
+fn start(_argc: isize, _argv: *const *const u8) -> isize {
for _ in [1,2,3].iter() { }
0
}
// pretty-expanded FIXME #23616
-pub fn main() { let x: Vec<int> = Vec::new(); for _ in &x { panic!("moop"); } }
+pub fn main() { let x: Vec<isize> = Vec::new(); for _ in &x { panic!("moop"); } }
// pretty-expanded FIXME #23616
-fn two<F>(mut it: F) where F: FnMut(int) { it(0); it(1); }
+fn two<F>(mut it: F) where F: FnMut(isize) { it(0); it(1); }
pub fn main() {
- let mut a: Vec<int> = vec!(-1, -1, -1, -1);
- let mut p: int = 0;
+ let mut a: Vec<isize> = vec!(-1, -1, -1, -1);
+ let mut p: isize = 0;
two(|i| {
- two(|j| { a[p as uint] = 10 * i + j; p += 1; })
+ two(|j| { a[p as usize] = 10 * i + j; p += 1; })
});
assert_eq!(a[0], 0);
assert_eq!(a[1], 1);
-fn pairs<F>(mut it: F) where F: FnMut((int, int)) {
- let mut i: int = 0;
- let mut j: int = 0;
+fn pairs<F>(mut it: F) where F: FnMut((isize, isize)) {
+ let mut i: isize = 0;
+ let mut j: isize = 0;
while i < 10 { it((i, j)); i += 1; j += i; }
}
pub fn main() {
- let mut i: int = 10;
- let mut j: int = 0;
+ let mut i: isize = 10;
+ let mut j: isize = 0;
pairs(|p| {
let (_0, _1) = p;
println!("{}", _0);
pub fn main() {
- let mut sum: int = 0;
+ let mut sum: isize = 0;
first_ten(|i| { println!("main"); println!("{}", i); sum = sum + i; });
println!("sum");
println!("{}", sum);
assert_eq!(sum, 45);
}
-fn first_ten<F>(mut it: F) where F: FnMut(int) {
- let mut i: int = 0;
+fn first_ten<F>(mut it: F) where F: FnMut(isize) {
+ let mut i: isize = 0;
while i < 10 { println!("first_ten"); it(i); i = i + 1; }
}
extern fn callback(data: libc::uintptr_t) {
unsafe {
- let data: *const int = mem::transmute(data);
+ let data: *const isize = mem::transmute(data);
assert_eq!(*data, 100);
}
}
}
}
-fn strlen(str: String) -> uint {
+fn strlen(str: String) -> usize {
// C string is terminated with a zero
let s = CString::new(str).unwrap();
unsafe {
- mlibc::my_strlen(s.as_ptr()) as uint
+ mlibc::my_strlen(s.as_ptr()) as usize
}
}
#![feature(lang_items, start, no_std, core, collections)]
#![no_std]
-extern crate "std" as other;
+extern crate std as other;
#[macro_use] extern crate core;
#[macro_use] extern crate collections;
use collections::string::ToString;
#[start]
-fn start(_argc: int, _argv: *const *const u8) -> int {
+fn start(_argc: isize, _argv: *const *const u8) -> isize {
let s = format!("{}", 1_isize);
assert_eq!(s, "1".to_string());
use std::marker::NoCopy as NP;
-struct ncint { np: NP, v: int }
-fn ncint(v: int) -> ncint { ncint { np: NP, v: v } }
+struct ncint { np: NP, v: isize }
+fn ncint(v: isize) -> ncint { ncint { np: NP, v: v } }
-struct NoFoo { copied: int, nocopy: ncint, }
+struct NoFoo { copied: isize, nocopy: ncint, }
impl NoFoo {
- fn new(x:int,y:int) -> NoFoo { NoFoo { copied: x, nocopy: ncint(y) } }
+ fn new(x:isize,y:isize) -> NoFoo { NoFoo { copied: x, nocopy: ncint(y) } }
}
-struct MoveFoo { copied: int, moved: Box<int>, }
+struct MoveFoo { copied: isize, moved: Box<isize>, }
impl MoveFoo {
- fn new(x:int,y:int) -> MoveFoo { MoveFoo { copied: x, moved: box y } }
+ fn new(x:isize,y:isize) -> MoveFoo { MoveFoo { copied: x, moved: box y } }
}
struct DropNoFoo { inner: NoFoo }
impl DropNoFoo {
- fn new(x:int,y:int) -> DropNoFoo { DropNoFoo { inner: NoFoo::new(x,y) } }
+ fn new(x:isize,y:isize) -> DropNoFoo { DropNoFoo { inner: NoFoo::new(x,y) } }
}
impl Drop for DropNoFoo { fn drop(&mut self) { } }
struct DropMoveFoo { inner: MoveFoo }
impl DropMoveFoo {
- fn new(x:int,y:int) -> DropMoveFoo { DropMoveFoo { inner: MoveFoo::new(x,y) } }
+ fn new(x:isize,y:isize) -> DropMoveFoo { DropMoveFoo { inner: MoveFoo::new(x,y) } }
}
impl Drop for DropMoveFoo { fn drop(&mut self) { } }
// pretty-expanded FIXME #23616
-fn ho<F>(f: F) -> int where F: FnOnce(int) -> int { let n: int = f(3); return n; }
+fn ho<F>(f: F) -> isize where F: FnOnce(isize) -> isize { let n: isize = f(3); return n; }
-fn direct(x: int) -> int { return x + 1; }
+fn direct(x: isize) -> isize { return x + 1; }
pub fn main() {
- let a: int = direct(3); // direct
- let b: int = ho(direct); // indirect unbound
+ let a: isize = direct(3); // direct
+ let b: isize = ho(direct); // indirect unbound
assert_eq!(a, b);
}
// pretty-expanded FIXME #23616
-fn f() -> int { return 42; }
+fn f() -> isize { return 42; }
pub fn main() {
- let g: fn() -> int = f;
- let i: int = g();
+ let g: fn() -> isize = f;
+ let i: isize = g();
assert_eq!(i, 42);
}
#![feature(box_syntax)]
struct Foo {
- x: Box<uint>,
- y: Box<uint>,
+ x: Box<usize>,
+ y: Box<usize>,
}
-fn foo(Foo {x, ..}: Foo) -> *const uint {
- let addr: *const uint = &*x;
+fn foo(Foo {x, ..}: Foo) -> *const usize {
+ let addr: *const usize = &*x;
addr
}
pub fn main() {
let obj: Box<_> = box 1;
- let objptr: *const uint = &*obj;
+ let objptr: *const usize = &*obj;
let f = Foo {x: obj, y: box 2};
let xptr = foo(f);
assert_eq!(objptr, xptr);
#![feature(box_patterns)]
#![feature(box_syntax)]
-fn getaddr(box ref x: Box<uint>) -> *const uint {
- let addr: *const uint = &*x;
+fn getaddr(box ref x: Box<usize>) -> *const usize {
+ let addr: *const usize = &*x;
addr
}
-fn checkval(box ref x: Box<uint>) -> uint {
+fn checkval(box ref x: Box<usize>) -> usize {
*x
}
pub fn main() {
let obj: Box<_> = box 1;
- let objptr: *const uint = &*obj;
+ let objptr: *const usize = &*obj;
let xptr = getaddr(obj);
assert_eq!(objptr, xptr);
// pretty-expanded FIXME #23616
-fn foo((x, _): (int, int)) -> int {
+fn foo((x, _): (isize, isize)) -> isize {
x
}
#[derive(Debug)]
struct Foo {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
pub fn main() {
pub fn main() {
let expected: Box<_> = box 100;
- let actual = id::<Box<int>>(expected.clone());
+ let actual = id::<Box<isize>>(expected.clone());
println!("{}", *actual);
assert_eq!(*expected, *actual);
}
struct Foo;
fn main() {
- let _a = Vec::<int>(None);
- let _b = Vec::<int, default_type_params_xc::FakeHeap>(None);
- let _c = default_type_params_xc::FakeVec::<int> { f: None };
- let _d = default_type_params_xc::FakeVec::<int, Foo> { f: None };
+ let _a = Vec::<isize>(None);
+ let _b = Vec::<isize, default_type_params_xc::FakeHeap>(None);
+ let _c = default_type_params_xc::FakeVec::<isize> { f: None };
+ let _d = default_type_params_xc::FakeVec::<isize, Foo> { f: None };
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct Foo<A = (int, char)> {
+struct Foo<A = (isize, char)> {
a: A
}
-impl Foo<int> {
- fn bar_int(&self) -> int {
+impl Foo<isize> {
+ fn bar_int(&self) -> isize {
self.a
}
}
impl Foo {
fn bar(&self) {
- let (i, c): (int, char) = self.a;
+ let (i, c): (isize, char) = self.a;
assert_eq!(Foo { a: i }.bar_int(), i);
assert_eq!(Foo { a: c }.bar_char(), c);
}
}
fn default_foo(x: Foo) {
- let (i, c): (int, char) = x.a;
+ let (i, c): (isize, char) = x.a;
assert_eq!(i, 1);
assert_eq!(c, 'a');
}
pub fn main() {
- let b = f::<int>(10);
+ let b = f::<isize>(10);
println!("{}" ,b.a);
println!("{}", b.b);
assert_eq!(b.a, 10);
fn reclift<T>(t: T) -> Recbox<T> { return Recbox {x: box t}; }
pub fn main() {
- let foo: int = 17;
- let rbfoo: Recbox<int> = reclift::<int>(foo);
+ let foo: isize = 17;
+ let rbfoo: Recbox<isize> = reclift::<isize>(foo);
assert_eq!(*rbfoo.x, foo);
}
#![feature(core)]
-use std::num::Int;
+use std::ops::Add;
-extern "C" fn foo<T: WrappingOps>(a: T, b: T) -> T { a.wrapping_add(b) }
+extern "C" fn foo<T: Add>(a: T, b: T) -> T::Output { a + b }
fn main() {
- assert_eq!(99u8, foo(255u8, 100u8));
- assert_eq!(99u16, foo(65535u16, 100u16));
+ assert_eq!(100u8, foo(0u8, 100u8));
+ assert_eq!(100u16, foo(0u16, 100u16));
}
fn id<T>(x: T) -> T { return x; }
-pub fn main() { let x: int = 42; let y: int = id(x); assert!((x == y)); }
+pub fn main() { let x: isize = 42; let y: isize = id(x); assert!((x == y)); }
pub fn foo<T>() { }
}
-pub fn main() { foomod::foo::<int>(); foomod::foo::<int>(); }
+pub fn main() { foomod::foo::<isize>(); foomod::foo::<isize>(); }
fn id<T>(x: T) -> T { return x; }
#[derive(Copy)]
-struct Triple {x: int, y: int, z: int}
+struct Triple {x: isize, y: isize, z: isize}
pub fn main() {
let mut x = 62;
let mut b = 'b';
let p: Triple = Triple {x: 65, y: 66, z: 67};
let mut q: Triple = Triple {x: 68, y: 69, z: 70};
- y = id::<int>(x);
+ y = id::<isize>(x);
println!("{}", y);
assert_eq!(x, y);
b = id::<char>(a);
}
struct S {
- x: int
+ x: isize
}
-impl Foo<int> for S {
- fn get(&self) -> int {
+impl Foo<isize> for S {
+ fn get(&self) -> isize {
self.x
}
}
pub fn main() {
let x = box S { x: 1 };
- let y = x as Box<Foo<int>>;
+ let y = x as Box<Foo<isize>>;
assert_eq!(y.get(), 1);
}
enum list<T> { cons(Box<T>, Box<list<T>>), nil, }
pub fn main() {
- let _a: list<int> =
- list::cons::<int>(box 10,
- box list::cons::<int>(box 12,
- box list::cons::<int>(box 13,
- box list::nil::<int>)));
+ let _a: list<isize> =
+ list::cons::<isize>(box 10,
+ box list::cons::<isize>(box 12,
+ box list::cons::<isize>(box 13,
+ box list::nil::<isize>)));
}
assert!((hit));
}
-pub fn main() { altfoo::<int>(foo::arm::<int>(10)); }
+pub fn main() { altfoo::<isize>(foo::arm::<isize>(10)); }
enum noption<T> { some(T), }
-struct Pair { x: int, y: int }
+struct Pair { x: isize, y: isize }
pub fn main() {
- let nop: noption<int> = noption::some::<int>(5);
- match nop { noption::some::<int>(n) => { println!("{}", n); assert!((n == 5)); } }
+ let nop: noption<isize> = noption::some::<isize>(5);
+ match nop { noption::some::<isize>(n) => { println!("{}", n); assert!((n == 5)); } }
let nop2: noption<Pair> = noption::some(Pair{x: 17, y: 42});
match nop2 {
noption::some(t) => {
enum option<T> { some(Box<T>), none, }
pub fn main() {
- let mut a: option<int> = option::some::<int>(box 10);
- a = option::none::<int>;
+ let mut a: option<isize> = option::some::<isize>(box 10);
+ a = option::none::<isize>;
}
// except according to those terms.
-fn mk() -> int { return 1; }
+fn mk() -> isize { return 1; }
-fn chk(a: int) { println!("{}", a); assert!((a == 1)); }
+fn chk(a: isize) { println!("{}", a); assert!((a == 1)); }
fn apply<T>(produce: fn() -> T,
consume: fn(T)) {
}
pub fn main() {
- let produce: fn() -> int = mk;
- let consume: fn(v: int) = chk;
- apply::<int>(produce, consume);
+ let produce: fn() -> isize = mk;
+ let consume: fn(v: isize) = chk;
+ apply::<isize>(produce, consume);
}
struct Pair<T> {x: T, y: T}
pub fn main() {
- let x: Pair<int> = Pair {x: 10, y: 12};
+ let x: Pair<isize> = Pair {x: 10, y: 12};
assert_eq!(x.x, 10);
assert_eq!(x.y, 12);
}
fn box_it<T>(x: Triple<T>) -> Box<Triple<T>> { return box x; }
pub fn main() {
- let x: Box<Triple<int>> = box_it::<int>(Triple{x: 1, y: 2, z: 3});
+ let x: Box<Triple<isize>> = box_it::<isize>(Triple{x: 1, y: 2, z: 3});
assert_eq!(x.y, 2);
}
// pretty-expanded FIXME #23616
-pub fn f() -> int { return 1; }
+pub fn f() -> isize { return 1; }
pub mod foo {
- pub fn f() -> int { return 2; }
+ pub fn f() -> isize { return 2; }
pub fn g() { assert!((f() == 2)); assert!((::f() == 1)); }
}
// pretty-expanded FIXME #23616
#[derive(Copy)]
-enum Q { R(Option<uint>) }
+enum Q { R(Option<usize>) }
-fn xyzzy(q: Q) -> uint {
+fn xyzzy(q: Q) -> usize {
match q {
Q::R(S) if S.is_some() => { 0 }
_ => 1
// pretty-expanded FIXME #23616
#[derive(Copy)]
-struct Pair { x: int, y: int }
+struct Pair { x: isize, y: isize }
pub fn main() {
- let a: int =
+ let a: isize =
match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
assert_eq!(a, 2);
- let b: int =
+ let b: isize =
match (Pair {x: 10, y: 20}) {
x if x.x < 5 && x.y < 5 => { 1 }
Pair {x: x, y: y} if x == 10 && y == 20 => { 2 }
pub type mapper = extern fn(String, putter);
- enum ctrl_proto { find_reducer(Vec<u8>, Sender<int>), mapper_done, }
+ enum ctrl_proto { find_reducer(Vec<u8>, Sender<isize>), mapper_done, }
fn start_mappers(ctrl: Sender<ctrl_proto>, inputs: Vec<String>) {
for i in &inputs {
fn map_task(ctrl: Sender<ctrl_proto>, input: String) {
let mut intermediates = HashMap::new();
- fn emit(im: &mut HashMap<String, int>,
+ fn emit(im: &mut HashMap<String, isize>,
ctrl: Sender<ctrl_proto>, key: String,
_val: String) {
if im.contains_key(&key) {
// This task becomes the master control task. It spawns others
// to do the rest.
- let mut reducers: HashMap<String, int>;
+ let mut reducers: HashMap<String, isize>;
reducers = HashMap::new();
start_mappers(tx, inputs.clone());
- let mut num_mappers = inputs.len() as int;
+ let mut num_mappers = inputs.len() as isize;
while num_mappers > 0 {
match rx.recv().unwrap() {
// pretty-expanded FIXME #23616
trait Typer<'tcx> {
- fn method(&self, data: &'tcx int) -> &'tcx int { data }
+ fn method(&self, data: &'tcx isize) -> &'tcx isize { data }
}
struct Tcx<'tcx> {
- fields: &'tcx int
+ fields: &'tcx isize
}
impl<'tcx> Typer<'tcx> for Tcx<'tcx> {
// pretty-expanded FIXME #23616
trait Typer<'tcx> {
- fn method(&self, data: &'tcx int) -> &'tcx int { data }
+ fn method(&self, data: &'tcx isize) -> &'tcx isize { data }
fn dummy(&self) { }
}
fn call(&self, arg: A) -> R;
}
-type FnObject<'b> = for<'a> FnLike<&'a int, &'a int> + 'b;
+type FnObject<'b> = for<'a> FnLike<&'a isize, &'a isize> + 'b;
struct Identity;
}
fn call_repeatedly<F>(f: F)
- where F : for<'a> FnLike<&'a int, &'a int>
+ where F : for<'a> FnLike<&'a isize, &'a isize>
{
let x = 3;
let y = f.call(&x);
#![feature(unboxed_closures)]
-// Test that `F : Fn(int) -> int + Send` is interpreted as two
+// Test that `F : Fn(isize) -> isize + Send` is interpreted as two
// distinct bounds on `F`.
fn foo1<F>(f: F)
- where F : FnOnce(int) -> int + Send
+ where F : FnOnce(isize) -> isize + Send
{
bar(f);
}
fn foo2<F>(f: F)
- where F : FnOnce(int) -> int + Send
+ where F : FnOnce(isize) -> isize + Send
{
baz(f);
}
fn bar<F:Send>(f: F) { }
-fn baz<F:FnOnce(int) -> int>(f: F) { }
+fn baz<F:FnOnce(isize) -> isize>(f: F) { }
fn main() {}
#![allow(unknown_features)]
#![feature(unboxed_closures)]
-// Test that `Fn(int) -> int + 'static` parses as `(Fn(int) -> int) +
-// 'static` and not `Fn(int) -> (int + 'static)`. The latter would
+// Test that `Fn(isize) -> isize + 'static` parses as `(Fn(isize) -> isize) +
+// 'static` and not `Fn(isize) -> (isize + 'static)`. The latter would
// cause a compilation error. Issue #18772.
-fn adder(y: int) -> Box<Fn(int) -> int + 'static> {
+fn adder(y: isize) -> Box<Fn(isize) -> isize + 'static> {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
Box::new(move |x| y + x)
}
fn call(&self, arg: A) -> R;
}
-type FnObject<'b> = for<'a> FnLike<&'a int, &'a int> + 'b;
+type FnObject<'b> = for<'a> FnLike<&'a isize, &'a isize> + 'b;
fn main() {
}
// pretty-expanded FIXME #23616
trait PrinterSupport<'ast> {
- fn ast_map(&self) -> Option<&'ast uint> { None }
+ fn ast_map(&self) -> Option<&'ast usize> { None }
}
struct NoAnn<'ast> {
- f: Option<&'ast uint>
+ f: Option<&'ast usize>
}
impl<'ast> PrinterSupport<'ast> for NoAnn<'ast> {
}
-fn foo<'ast, G>(f: Option<&'ast uint>, g: G) where G: FnOnce(&PrinterSupport) {
+fn foo<'ast, G>(f: Option<&'ast usize>, g: G) where G: FnOnce(&PrinterSupport) {
let annotation = NoAnn { f: f };
g(&annotation)
}
#![feature(unboxed_closures)]
-fn foo<F:Fn(&int)>(f: F) {
+fn foo<F:Fn(&isize)>(f: F) {
let x = 22;
f(&x);
}
fn main() {
- foo(|x: &int| println!("{}", *x));
+ foo(|x: &isize| println!("{}", *x));
}
// pretty-expanded FIXME #23616
mod x {
- pub fn g() -> uint {14}
+ pub fn g() -> usize {14}
}
pub fn main(){
pub fn main() {
let mut i = 0;
- let j: int = {
+ let j: isize = {
'x: loop {
// this 'x should refer to the outer loop, lexically
loop_x!(break 'x);
};
assert_eq!(j, 1);
- let k: int = {
+ let k: isize = {
'x: for _ in 0..1 {
// ditto
loop_x!(break 'x);
};
assert_eq!(k, 1);
- let l: int = {
+ let l: isize = {
'x: for _ in 0..1 {
// ditto
while_true!(break 'x);
};
assert_eq!(l, 1);
- let n: int = {
+ let n: isize = {
'x: for _ in 0..1 {
// ditto
run_once!(continue 'x);
// except according to those terms.
pub fn main() {
- let i: int = if false { panic!() } else { 5 };
+ let i: isize = if false { panic!() } else { 5 };
println!("{}", i);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn even(x: uint) -> bool {
+fn even(x: usize) -> bool {
if x < 2 {
return false;
} else if x == 2 { return true; } else { return even(x - 2); }
}
-fn foo(x: uint) {
+fn foo(x: usize) {
if even(x) {
println!("{}", x);
} else {
worked = true;
}
assert!(worked);
- let clause: uint;
+ let clause: usize;
if let None = Some("test") {
clause = 1;
} else if 4_usize > 5 {
enum Foo {
One,
- Two(uint),
- Three(String, int)
+ Two(usize),
+ Three(String, isize)
}
let foo = Foo::Three("three".to_string(), 42);
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
-struct Foo(int, int, int, int);
-struct Bar{a: int, b: int, c: int, d: int}
+struct Foo(isize, isize, isize, isize);
+struct Bar{a: isize, b: isize, c: isize, d: isize}
pub fn main() {
let Foo(..) = Foo(5, 5, 5, 5);
enum option__ {
none__,
- some__(int)
+ some__(isize)
}
impl option__ {
// except according to those terms.
mod foo {
- pub fn x(y: int) { println!("{}", y); }
+ pub fn x(y: isize) { println!("{}", y); }
}
mod bar {
use foo::x as z;
mod foo {
- pub fn x(y: int) { println!("{}", y); }
+ pub fn x(y: isize) { println!("{}", y); }
}
pub fn main() { x(10); z(10); }
// pretty-expanded FIXME #23616
-fn f() -> Vec<int> { Vec::new() }
+fn f() -> Vec<isize> { Vec::new() }
pub fn main() { }
*/
// ignore-test
-fn loopy(n: int) {
+fn loopy(n: isize) {
if n > 0 { spawn(move|| { loopy(n - 1) }); spawn(move|| { loopy(n - 1) }); }
loop { }
}
// as a move unless the stored thing is used afterwards.
struct r<'a> {
- i: &'a Cell<int>,
+ i: &'a Cell<isize>,
}
struct BoxR<'a> { x: r<'a> }
}
}
-fn r(i: &Cell<int>) -> r {
+fn r(i: &Cell<isize>) -> r {
r {
i: i
}
// even though it would be if the nxt field had type @foo:
struct foo(X);
-struct X { x: uint, nxt: *const foo }
+struct X { x: usize, nxt: *const foo }
pub fn main() {
let _x = foo(X {x: 0, nxt: ptr::null()});
// pretty-expanded FIXME #23616
-pub fn main() { let _x: int = 10; }
+pub fn main() { let _x: isize = 10; }
fn id_i32(n: i32) -> i32 { n }
fn id_i64(n: i64) -> i64 { n }
- fn id_uint(n: uint) -> uint { n }
+ fn id_uint(n: usize) -> usize { n }
fn id_u8(n: u8) -> u8 { n }
fn id_u16(n: u16) -> u16 { n }
fn id_u32(n: u32) -> u32 { n }
id_i64(j);
id_i64(-9_223_372_036_854_775_808);
- let _i: uint = 1;
+ let _i: usize = 1;
let j = 1;
id_uint(j);
id_uint(1);
// except according to those terms.
// Regression test for type inference failure around shifting. In this
-// case, the iteration yields an int, but we hadn't run the full type
+// case, the iteration yields an isize, but we hadn't run the full type
// propagation yet, and so we just saw a type variable, yielding an
// error.
mod rusti {
extern "rust-intrinsic" {
- pub fn pref_align_of<T>() -> uint;
- pub fn min_align_of<T>() -> uint;
+ pub fn pref_align_of<T>() -> usize;
+ pub fn min_align_of<T>() -> usize;
}
}
#![allow(unknown_features)]
#![feature(box_syntax)]
#![feature(intrinsics)]
+// needed to check for drop fill word.
+#![feature(filling_drop)]
-use std::mem::transmute;
+use std::mem::{self, transmute};
mod rusti {
extern "rust-intrinsic" {
unsafe {
let x: Box<_> = box 1;
let mut y = rusti::init();
- let mut z: *const uint = transmute(&x);
+ let mut z: *const usize = transmute(&x);
rusti::move_val_init(&mut y, x);
assert_eq!(*y, 1);
- assert_eq!(*z, 0); // `x` is nulled out, not directly visible
+ // `x` is nulled out, not directly visible
+ assert_eq!(*z, mem::POST_DROP_USIZE);
}
}
fn return_address() -> *const u8;
}
-fn f(result: &mut uint) -> Point {
+fn f(result: &mut usize) -> Point {
unsafe {
- *result = return_address() as uint;
+ *result = return_address() as usize;
Point {
x: 1.0,
y: 2.0,
fn main() {
let mut intrinsic_reported_address = 0;
let pt = f(&mut intrinsic_reported_address);
- let actual_address = &pt as *const Point as uint;
+ let actual_address = &pt as *const Point as usize;
assert_eq!(intrinsic_reported_address, actual_address);
}
}
}
pub fn main() {
- let _a : int = unsafe {rusti::uninit()};
+ let _a : isize = unsafe {rusti::uninit()};
}
// See also src/test/run-make/intrinsic-unreachable.
-unsafe fn f(x: uint) -> uint {
+unsafe fn f(x: usize) -> usize {
match x {
17 => 23,
_ => intrinsics::unreachable(),
// pretty-expanded FIXME #23616
-extern crate "issue-10028" as issue10028;
+extern crate issue_10028 as issue10028;
use issue10028::ZeroLengthThingWithDestructor;
// pretty-expanded FIXME #23616
-struct A { foo: int }
-struct B { a: int, b: int, c: int }
+struct A { foo: isize }
+struct B { a: isize, b: isize, c: isize }
fn mka() -> A { panic!() }
fn mkb() -> B { panic!() }
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn work(_: Box<int>) {}
+fn work(_: Box<isize>) {}
fn foo<F:FnOnce()>(_: F) {}
pub fn main() {
#![feature(unsafe_no_drop_flag)]
-static mut drop_count: uint = 0;
+static mut drop_count: usize = 0;
#[unsafe_no_drop_flag]
struct Foo {
// pretty-expanded FIXME #23616
-pub fn foo() -> int {
+pub fn foo() -> isize {
3
}
-pub fn bar() -> int {
+pub fn bar() -> isize {
4
}
pub mod baz {
use {foo, bar};
- pub fn quux() -> int {
+ pub fn quux() -> isize {
foo() + bar()
}
}
pub mod grault {
use {foo};
- pub fn garply() -> int {
+ pub fn garply() -> isize {
foo()
}
}
pub mod waldo {
use {};
- pub fn plugh() -> int {
+ pub fn plugh() -> isize {
0
}
}
struct Foo {
#[cfg(fail)]
bar: baz,
- foo: int,
+ foo: isize,
}
struct Foo2 {
#[cfg(foo)]
- foo: int,
+ foo: isize,
}
enum Bar1 {
enum Bar3 {
Bar3_1 {
#[cfg(fail)]
- foo: int,
- bar: int,
+ foo: isize,
+ bar: isize,
}
}
}
pub fn main() {
- let x: X<int> = X {
+ let x: X<isize> = X {
a: 12345678,
b: 9,
c: true,
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
trait Foo { fn dummy(&self) { } }
-impl Foo for int {}
+impl Foo for isize {}
fn foo(_: [&Foo; 2]) {}
fn foos(_: &[&Foo]) {}
fn foog<T>(_: &[T], _: &[T]) {}
// pretty-expanded FIXME #23616
-extern crate "issue-11224" as unused;
+extern crate issue_11224 as unused;
pub fn main() {}
// pretty-expanded FIXME #23616
-extern crate "issue-11225-1" as foo;
+extern crate issue_11225_1 as foo;
pub fn main() {
foo::foo(1);
// pretty-expanded FIXME #23616
-extern crate "issue-11225-2" as foo;
+extern crate issue_11225_2 as foo;
pub fn main() {
foo::foo(1);
trait T<U> {
fn next(&mut self) -> Option<U>;
}
-impl T<int> for Empty {
- fn next(&mut self) -> Option<int> { None }
+impl T<isize> for Empty {
+ fn next(&mut self) -> Option<isize> { None }
}
-fn do_something_with(a : &mut T<int>) {
+fn do_something_with(a : &mut T<isize>) {
println!("{:?}", a.next())
}
// aux-build:issue-11508.rs
-extern crate "issue-11508" as rand;
+extern crate issue_11508 as rand;
use rand::{Closed01, random};
// pretty-expanded FIXME #23616
-extern crate "issue-11529" as a;
+extern crate issue_11529 as a;
fn main() {
let one = 1;
#[derive(Clone)]
enum Noun
{
- Atom(int),
+ Atom(isize),
Cell(Box<Noun>, Box<Noun>)
}
// Destructuring struct variants would ICE where regular structs wouldn't
enum Foo {
- VBar { num: int }
+ VBar { num: isize }
}
-struct SBar { num: int }
+struct SBar { num: isize }
pub fn main() {
let vbar = Foo::VBar { num: 1 };
--- /dev/null
+// Copyright 2015 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.
+
+//! Ensure the private trait Bar isn't complained about.
+
+#![deny(missing_docs)]
+
+mod foo {
+ trait Bar { fn bar(&self) { } }
+ impl Bar for i8 { fn bar(&self) { } }
+}
+
+fn main() { }
g: Box<X<T>+'static>}
struct F;
-impl X<int> for F {
+impl X<isize> for F {
}
fn main() {
// Generate sieve of Eratosthenes for n up to 1e6
let n = 1000000;
let mut sieve = BitVec::from_elem(n+1, true);
- let limit: uint = (n as f32).sqrt() as uint;
+ let limit: usize = (n as f32).sqrt() as usize;
for i in 2..limit+1 {
if sieve[i] {
let mut j = 0;
#[derive(Encodable)]
struct Bar {
- froboz: uint,
+ froboz: usize,
}
enum WireProtocol {
// pretty-expanded FIXME #23616
-extern crate "issue-12133-rlib" as a;
-extern crate "issue-12133-dylib" as b;
+extern crate issue_12133_rlib as a;
+extern crate issue_12133_dylib as b;
fn main() {}
// pretty-expanded FIXME #23616
-extern crate "issue-12133-rlib" as a;
-extern crate "issue-12133-dylib" as b;
+extern crate issue_12133_rlib as a;
+extern crate issue_12133_dylib as b;
fn main() {}
// pretty-expanded FIXME #23616
-extern crate "issue-12133-dylib2" as other;
+extern crate issue_12133_dylib2 as other;
fn main() {}
#[derive(Copy, PartialEq, Eq, Hash)]
struct XYZ {
- x: int,
- y: int,
- z: int
+ x: isize,
+ y: isize,
+ z: isize
}
fn main() {
let v2: Vec<_> = arr.iter().map(copy).collect();
let m1: HashMap<_, _> = arr.iter().map(copy).collect();
- let m2: HashMap<int, _> = arr.iter().map(copy).collect();
- let m3: HashMap<_, uint> = arr.iter().map(copy).collect();
+ let m2: HashMap<isize, _> = arr.iter().map(copy).collect();
+ let m3: HashMap<_, usize> = arr.iter().map(copy).collect();
}
// Tests that match expression handles overlapped literal and range
// properly in the presence of guard function.
-fn val() -> uint { 1 }
+#![feature(slice_patterns)]
-static CONST: uint = 1;
+fn val() -> usize { 1 }
+
+static CONST: usize = 1;
pub fn main() {
lit_shadow_range();
fn misc() {
enum Foo {
- Bar(uint, bool)
+ Bar(usize, bool)
}
// This test basically mimics how trace_macros! macro is implemented,
// which is a rare combination of vector patterns, multiple wild-card
self.iter.by_ref().map(|&(key, ref value)| (key, value)).next()
}
- fn size_hint(&self) -> (uint, Option<uint>) {
+ fn size_hint(&self) -> (usize, Option<usize>) {
self.iter.size_hint()
}
}
// pretty-expanded FIXME #23616
pub trait Foo {
- fn bar<'a, I: Iterator<Item=&'a ()>>(&self, it: I) -> uint {
+ fn bar<'a, I: Iterator<Item=&'a ()>>(&self, it: I) -> usize {
let mut xs = it.filter(|_| true);
xs.count()
}
struct Node;
impl Node {
- fn RemoveChild(&self, _a: uint) {
+ fn RemoveChild(&self, _a: usize) {
}
- fn AddChild(&self, _a: uint) {
+ fn AddChild(&self, _a: usize) {
}
}
+++ /dev/null
-// 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.
-
-// pretty-expanded FIXME #23616
-
-#![feature(std_misc, libc)]
-
-extern crate libc;
-
-use std::thunk::Thunk;
-
-fn foo(_: Thunk) {}
-
-fn main() {
- foo(loop {
- unsafe { libc::exit(0 as libc::c_int); }
- });
- 2_usize + (loop {});
-}
struct Foo<'a> {
i: &'a bool,
- j: Option<&'a int>,
+ j: Option<&'a isize>,
}
impl<'a> Foo<'a> {
- fn bar(&mut self, j: &int) {
+ fn bar(&mut self, j: &isize) {
let child = Foo {
i: self.i,
j: Some(j)
fn main() {
let (tx, rx) = channel();
let _t = Thread::spawn(move|| { helper(rx) });
- let (snd, rcv) = channel::<int>();
+ let (snd, rcv) = channel::<isize>();
for _ in 1..100000 {
snd.send(1).unwrap();
let (tx2, rx2) = channel();
// pretty-expanded FIXME #23616
-extern crate "issue-13620-2" as crate2;
+extern crate issue_13620_2 as crate2;
fn main() {
(crate2::FOO2.foo)();
// pretty-expanded FIXME #23616
-pub struct Foo<'a, 'b: 'a> { foo: &'a &'b int }
+pub struct Foo<'a, 'b: 'a> { foo: &'a &'b isize }
pub fn foo<'a, 'b>(x: Foo<'a, 'b>, _o: Option<& & ()>) { let _y = x.foo; }
fn main() {}
use std::u8;
-const NUM: uint = u8::BITS as uint;
+const NUM: usize = u8::BITS as usize;
-struct MyStruct { nums: [uint; 8] }
+struct MyStruct { nums: [usize; 8] }
fn main() {
// pretty-expanded FIXME #23616
trait Foo {
- fn bar(&self, int) {}
+ fn bar(&self, isize) {}
}
fn main() {}
// pretty-expanded FIXME #23616
struct TestStruct {
- x: *const [int; 2]
+ x: *const [isize; 2]
}
unsafe impl Sync for TestStruct {}
-static TEST_VALUE : TestStruct = TestStruct{x: 0x1234 as *const [int; 2]};
+static TEST_VALUE : TestStruct = TestStruct{x: 0x1234 as *const [isize; 2]};
fn main() {}
// pretty-expanded FIXME #23616
enum Foo {
- FooUint(uint),
+ FooUint(usize),
FooNullary,
}
// pretty-expanded FIXME #23616
-extern crate "issue-13872-3" as other;
+extern crate issue_13872_3 as other;
fn main() {
other::foo();
}
struct BarTy {
- x : int,
+ x : isize,
y : f64,
}
}
// If these fail, it's necessary to update rustc_resolve and the cfail tests.
-impl Foo for *const int {
+impl Foo for *const isize {
fn bar(&self) {
self.baz();
- Foo::bah(None::<*const int>);
+ Foo::bah(None::<*const isize>);
}
}
// If these fail, it's necessary to update rustc_resolve and the cfail tests.
-impl<'a> Foo for &'a int {
+impl<'a> Foo for &'a isize {
fn bar(&self) {
self.baz();
- Foo::bah(None::<&int>);
+ Foo::bah(None::<&isize>);
}
}
// If these fail, it's necessary to update rustc_resolve and the cfail tests.
-impl<'a> Foo for &'a mut int {
+impl<'a> Foo for &'a mut isize {
fn bar(&self) {
self.baz();
- Foo::bah(None::<&mut int>);
+ Foo::bah(None::<&mut isize>);
}
}
// If these fail, it's necessary to update rustc_resolve and the cfail tests.
-impl Foo for Box<int> {
+impl Foo for Box<isize> {
fn bar(&self) {
self.baz();
- Foo::bah(None::<Box<int>>);
+ Foo::bah(None::<Box<isize>>);
}
}
// pretty-expanded FIXME #23616
-struct A(int);
+struct A(isize);
struct B;
fn main() {
// pretty-expanded FIXME #23616
-#[macro_use] extern crate "std" as std2;
+#[macro_use] extern crate std as std2;
fn main() {}
// pretty-expanded FIXME #23616
-extern crate "issue-14421" as bug_lib;
+extern crate issue_14421 as bug_lib;
use bug_lib::B;
use bug_lib::make;
// pretty-expanded FIXME #23616
-extern crate "issue-14422" as bug_lib;
+extern crate issue_14422 as bug_lib;
use bug_lib::B;
use bug_lib::make;
}
trait Foo { fn dummy(&self) { }}
-struct Output(int);
+struct Output(isize);
impl Foo for Output {}
// pretty-expanded FIXME #23616
pub fn main() {
- {|i| if 1 == i { }};
+ {|i: u32| if 1 == i { }};
}
#[deny(dead_code)]
pub enum Foo {
Bar {
- baz: int
+ baz: isize
}
}
// pretty-expanded FIXME #23616
enum X {
- Foo(uint),
+ Foo(usize),
Bar(bool)
}
// pretty-expanded FIXME #23616
trait Matcher {
- fn next_match(&mut self) -> Option<(uint, uint)>;
+ fn next_match(&mut self) -> Option<(usize, usize)>;
}
struct CharPredMatcher<'a, 'b> {
}
impl<'a, 'b> Matcher for CharPredMatcher<'a, 'b> {
- fn next_match(&mut self) -> Option<(uint, uint)> {
+ fn next_match(&mut self) -> Option<(usize, usize)> {
None
}
}
}
impl<M: Matcher> Iterator for MatchIndices<M> {
- type Item = (uint, uint);
+ type Item = (usize, usize);
- fn next(&mut self) -> Option<(uint, uint)> {
+ fn next(&mut self) -> Option<(usize, usize)> {
self.matcher.next_match()
}
}
fn main() {
let s = "abcbdef";
match_indices(s, |c: char| c == 'b')
- .collect::<Vec<(uint, uint)>>();
+ .collect::<Vec<(usize, usize)>>();
}
// pretty-expanded FIXME #23616
-pub type BigRat<T = int> = T;
+pub type BigRat<T = isize> = T;
fn main() {}
macro_rules! demo {
( $output_constraint:tt ) => {
{
- let mut x: int = 0;
- let y: int = 1;
+ let mut x: isize = 0;
+ let y: isize = 1;
let mut history: History = vec!();
unsafe {
struct S<T>(T);
-static s1: S<S<uint>>=S(S(0));
-static s2: S<uint>=S(0);
+static s1: S<S<usize>>=S(S(0));
+static s2: S<usize>=S(0);
fn main() {
- let foo: S<S<uint>>=S(S(0));
- let foo: S<uint>=S(0);
+ let foo: S<S<usize>>=S(S(0));
+ let foo: S<usize>=S(0);
}
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
fn main() {
let mut x: &[_] = &[1, 2, 3, 4];
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
fn main() {
assert_eq!(count_members(&[1, 2, 3, 4]), 4);
}
-fn count_members(v: &[uint]) -> uint {
+fn count_members(v: &[usize]) -> usize {
match v {
[] => 0,
[_] => 1,
}
pub enum V {
- V1(int),
+ V1(isize),
V2(bool)
}
// checking that it ends_with the executable name. This
// is needed because of Windows, which has a different behavior.
// See #15149 for more info.
- return assert!(args[0].ends_with(&format!("mytest{}", env::consts::EXE_SUFFIX)[]));
+ return assert!(args[0].ends_with(&format!("mytest{}", env::consts::EXE_SUFFIX)));
}
test();
// pretty-expanded FIXME #23616
-static mut n_mut: uint = 0;
+static mut n_mut: usize = 0;
-static n: &'static uint = unsafe{ &n_mut };
+static n: &'static usize = unsafe{ &n_mut };
fn main() {}
t.foo()
}
-fn thing(a: int, b: int) -> int {
+fn thing(a: isize, b: isize) -> isize {
a + b
}
fn main() {
- let thing: fn(int, int) -> int = thing; // coerce to fn type
+ let thing: fn(isize, isize) -> isize = thing; // coerce to fn type
bar(&thing);
}
// pretty-expanded FIXME #23616
-extern crate "issue-15562" as i;
+extern crate issue_15562 as i;
pub fn main() {
extern {
#[derive(PartialEq)]
enum Test<'a> {
- Slice(&'a int)
+ Slice(&'a isize)
}
fn main() {
#[derive(Clone)]
enum Test<'a> {
- Slice(&'a int)
+ Slice(&'a isize)
}
fn main() {}
use std::ops::Index;
-struct Mat<T> { data: Vec<T>, cols: uint, }
+struct Mat<T> { data: Vec<T>, cols: usize, }
impl<T> Mat<T> {
- fn new(data: Vec<T>, cols: uint) -> Mat<T> {
+ fn new(data: Vec<T>, cols: usize) -> Mat<T> {
Mat { data: data, cols: cols }
}
- fn row<'a>(&'a self, row: uint) -> Row<&'a Mat<T>> {
+ fn row<'a>(&'a self, row: usize) -> Row<&'a Mat<T>> {
Row { mat: self, row: row, }
}
}
-impl<T> Index<(uint, uint)> for Mat<T> {
+impl<T> Index<(usize, usize)> for Mat<T> {
type Output = T;
- fn index<'a>(&'a self, (row, col): (uint, uint)) -> &'a T {
+ fn index<'a>(&'a self, (row, col): (usize, usize)) -> &'a T {
&self.data[row * self.cols + col]
}
}
-impl<'a, T> Index<(uint, uint)> for &'a Mat<T> {
+impl<'a, T> Index<(usize, usize)> for &'a Mat<T> {
type Output = T;
- fn index<'b>(&'b self, index: (uint, uint)) -> &'b T {
+ fn index<'b>(&'b self, index: (usize, usize)) -> &'b T {
(*self).index(index)
}
}
-struct Row<M> { mat: M, row: uint, }
+struct Row<M> { mat: M, row: usize, }
-impl<T, M: Index<(uint, uint), Output=T>> Index<uint> for Row<M> {
+impl<T, M: Index<(usize, usize), Output=T>> Index<usize> for Row<M> {
type Output = T;
- fn index<'a>(&'a self, col: uint) -> &'a T {
+ fn index<'a>(&'a self, col: usize) -> &'a T {
&self.mat[(self.row, col)]
}
}
let e = r[2];
assert!(e == 6);
- let e: uint = r[2];
+ let e: usize = r[2];
assert!(e == 6);
}
#[derive(PartialEq, Debug)]
struct Bar {
- x: int
+ x: isize
}
impl Drop for Bar {
fn drop(&mut self) {
#[derive(PartialEq, Debug)]
struct Foo {
x: Bar,
- a: int
+ a: isize
}
-fn foo() -> Result<Foo, int> {
+fn foo() -> Result<Foo, isize> {
return Ok(Foo {
x: Bar { x: 22 },
a: return Err(32)
});
}
-fn baz() -> Result<Foo, int> {
+fn baz() -> Result<Foo, isize> {
Ok(Foo {
x: Bar { x: 22 },
a: return Err(32)
}
// explicit immediate return
-fn aa() -> int {
+fn aa() -> isize {
return 3;
}
// implicit immediate return
-fn bb() -> int {
+fn bb() -> isize {
3
}
// implicit outptr return
-fn cc() -> Result<int, int> {
+fn cc() -> Result<isize, isize> {
Ok(3)
}
// explicit outptr return
-fn dd() -> Result<int, int> {
+fn dd() -> Result<isize, isize> {
return Ok(3);
}
trait A {
- fn aaa(&self) -> int {
+ fn aaa(&self) -> isize {
3
}
- fn bbb(&self) -> int {
+ fn bbb(&self) -> isize {
return 3;
}
- fn ccc(&self) -> Result<int, int> {
+ fn ccc(&self) -> Result<isize, isize> {
Ok(3)
}
- fn ddd(&self) -> Result<int, int> {
+ fn ddd(&self) -> Result<isize, isize> {
return Ok(3);
}
}
-impl A for int {}
+impl A for isize {}
fn main() {
assert_eq!(foo(), Err(32));
assert_eq!(cc().unwrap(), 3);
assert_eq!(dd().unwrap(), 3);
- let i = box 32i as Box<A>;
+ let i = box 32i
s as Box<A>;
assert_eq!(i.aaa(), 3);
- let i = box 32i as Box<A>;
+ let i = box 32i
s as Box<A>;
assert_eq!(i.bbb(), 3);
- let i = box 32i as Box<A>;
+ let i = box 32i
s as Box<A>;
assert_eq!(i.ccc().unwrap(), 3);
- let i = box 32i as Box<A>;
+ let i = box 32i
s as Box<A>;
assert_eq!(i.ddd().unwrap(), 3);
}
}
#[inline(never)]
-fn foo(x: Enum) -> int {
+fn foo(x: Enum) -> isize {
match x {
Enum::Variant1(true) => 1,
Enum::Variant1(false) => 2,
use std::mem;
-static mut DROP_COUNT: uint = 0;
+static mut DROP_COUNT: usize = 0;
struct Fragment;
fn main() {
if true { return }
match () {
- () => { static MAGIC: uint = 0; }
+ () => { static MAGIC: usize = 0; }
}
}
use std::cell::Cell;
struct Field {
- number: uint,
- state: Rc<Cell<uint>>
+ number: usize,
+ state: Rc<Cell<usize>>
}
impl Field {
- fn new(number: uint, state: Rc<Cell<uint>>) -> Field {
+ fn new(number: usize, state: Rc<Cell<usize>>) -> Field {
Field {
number: number,
state: state
fn main() {
let y = 0u8;
- let closure = move |x| y + x;
+ let closure = move |x: u8| y + x;
// Check that both closures are capturing by value
assert_eq!(1, mem::size_of_val(&closure));
// pretty-expanded FIXME #23616
pub fn main() {
- static _x: int = 1<<2;
+ static _x: isize = 1<<2;
}
// pretty-expanded FIXME #23616
-extern crate "issue-16643" as i;
+extern crate issue_16643 as i;
pub fn main() {
- i::TreeBuilder { h: 3u }.process_token();
+ i::TreeBuilder { h: 3 }.process_token();
}
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
fn main() {
- let x: (int, &[int]) = (2, &[1, 2]);
+ let x: (isize, &[isize]) = (2, &[1, 2]);
assert_eq!(match x {
(0, [_, _]) => 0,
(1, _) => 1,
use std::ops::{Deref, DerefMut};
-struct X(Box<int>);
+struct X(Box<isize>);
static mut DESTRUCTOR_RAN: bool = false;
}
impl Deref for X {
- type Target = int;
+ type Target = isize;
- fn deref(&self) -> &int {
+ fn deref(&self) -> &isize {
let &X(box ref x) = self;
x
}
}
impl DerefMut for X {
- fn deref_mut(&mut self) -> &mut int {
+ fn deref_mut(&mut self) -> &mut isize {
let &mut X(box ref mut x) = self;
x
}
// binding of a for loop
// pretty-expanded FIXME #23616
-fn foo<'a>(v: &'a [uint]) -> &'a uint {
+fn foo<'a>(v: &'a [usize]) -> &'a usize {
for &ref x in v { return x; }
unreachable!()
}
static mut DROPPED: [bool; 2] = [false, false];
-struct A(uint);
-struct Foo { _a: A, _b: int }
+struct A(usize);
+struct Foo { _a: A, _b: isize }
impl Drop for A {
fn drop(&mut self) {
// except according to those terms.
fn main() {
- let s: &[int] = &[0, 1, 2, 3, 4];
- let ss: &&[int] = &s;
- let sss: &&&[int] = &ss;
+ let s: &[isize] = &[0, 1, 2, 3, 4];
+ let ss: &&[isize] = &s;
+ let sss: &&&[isize] = &ss;
println!("{:?}", &s[..3]);
println!("{:?}", &ss[3..]);
// pretty-expanded FIXME #23616
-extern crate "issue-17662" as i;
+extern crate issue_17662 as i;
use std::marker;
struct Bar<'a> { m: marker::PhantomData<&'a ()> }
-impl<'a> i::Foo<'a, uint> for Bar<'a> {
- fn foo(&self) -> uint { 5 }
+impl<'a> i::Foo<'a, usize> for Bar<'a> {
+ fn foo(&self) -> usize { 5 }
}
pub fn main() {
// pretty-expanded FIXME #23616
-const FOO: uint = 3;
+const FOO: usize = 3;
fn main() {
assert_eq!(FOO, 3);
unsafe impl<T: Send> Sync for UnsafeEnum<T> {}
-static STATIC1: UnsafeEnum<int> = UnsafeEnum::VariantSafe;
+static STATIC1: UnsafeEnum<isize> = UnsafeEnum::VariantSafe;
-static STATIC2: MyUnsafePack<int> = MyUnsafePack(UnsafeCell { value: 1 });
-const CONST: MyUnsafePack<int> = MyUnsafePack(UnsafeCell { value: 1 });
-static STATIC3: MyUnsafe<int> = MyUnsafe{value: CONST};
+static STATIC2: MyUnsafePack<isize> = MyUnsafePack(UnsafeCell { value: 1 });
+const CONST: MyUnsafePack<isize> = MyUnsafePack(UnsafeCell { value: 1 });
+static STATIC3: MyUnsafe<isize> = MyUnsafe{value: CONST};
-static STATIC4: &'static MyUnsafePack<int> = &STATIC2;
+static STATIC4: &'static MyUnsafePack<isize> = &STATIC2;
struct Wrap<T> {
value: T
unsafe impl<T: Send> Sync for Wrap<T> {}
-static UNSAFE: MyUnsafePack<int> = MyUnsafePack(UnsafeCell{value: 2});
-static WRAPPED_UNSAFE: Wrap<&'static MyUnsafePack<int>> = Wrap { value: &UNSAFE };
+static UNSAFE: MyUnsafePack<isize> = MyUnsafePack(UnsafeCell{value: 2});
+static WRAPPED_UNSAFE: Wrap<&'static MyUnsafePack<isize>> = Wrap { value: &UNSAFE };
fn main() {
let a = &STATIC1;
#![feature(core)]
-extern crate "issue-17718" as other;
+extern crate issue_17718 as other;
use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
-const C1: uint = 1;
+const C1: usize = 1;
const C2: AtomicUsize = ATOMIC_USIZE_INIT;
const C3: fn() = foo;
-const C4: uint = C1 * C1 + C1 / C1;
-const C5: &'static uint = &C4;
-const C6: uint = {
- const C: uint = 3;
+const C4: usize = C1 * C1 + C1 / C1;
+const C5: &'static usize = &C4;
+const C6: usize = {
+ const C: usize = 3;
C
};
-static S1: uint = 3;
+static S1: usize = 3;
static S2: AtomicUsize = ATOMIC_USIZE_INIT;
mod test {
- static A: uint = 4;
- static B: &'static uint = &A;
- static C: &'static uint = &(A);
+ static A: usize = 4;
+ static B: &'static usize = &A;
+ static C: &'static usize = &(A);
}
fn foo() {}
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
fn main() {
assert_eq!(match [0u8; 1024] {
_ => 42_usize,
use std::thunk::Thunk;
-fn action(cb: Thunk<uint, uint>) -> uint {
+fn action(cb: Thunk<usize, usize>) -> usize {
cb.invoke(1)
}
// pretty-expanded FIXME #23616
trait Foo {
- fn foo(&self) -> uint;
+ fn foo(&self) -> usize;
}
-struct A(uint);
+struct A(usize);
impl A {
- fn bar(&self) -> uint { self.0 }
+ fn bar(&self) -> usize { self.0 }
}
impl Foo for A {
- fn foo(&self) -> uint { self.bar() }
+ fn foo(&self) -> usize { self.bar() }
}
fn main() {
// aux-build:issue-18501.rs
// pretty-expanded FIXME #23616
-extern crate "issue-18501" as issue;
+extern crate issue_18501 as issue;
fn main() {
issue::pass_method();
// aux-build:issue-18514.rs
// pretty-expanded FIXME #23616
-extern crate "issue-18514" as ice;
+extern crate issue_18514 as ice;
use ice::{Tr, St};
fn main() {
struct Foo;
-fn uint_to_foo(_: uint) -> Foo {
+fn uint_to_foo(_: usize) -> Foo {
Foo
}
// pretty-expanded FIXME #23616
mod a {
- pub type rust_task = uint;
+ pub type rust_task = usize;
pub mod rustrt {
use super::rust_task;
extern {
#![feature(unboxed_closures)]
// aux-build:issue-18711.rs
-extern crate "issue-18711" as issue;
+extern crate issue_18711 as issue;
fn main() {
(|| issue::inner(()))();
#[derive(Eq, PartialEq, PartialOrd, Ord)]
enum Test<'a> {
- Int(&'a int),
+ Int(&'a isize),
Slice(&'a [u8]),
}
}
fn main() {
- assert_eq!(module_path!(), "issue-18859");
- assert_eq!(foo::bar::baz::name(), "issue-18859::foo::bar::baz");
+ assert_eq!(module_path!(), "issue_18859");
+ assert_eq!(foo::bar::baz::name(), "issue_18859::foo::bar::baz");
}
// pretty-expanded FIXME #23616
-extern crate "issue-19340-1" as lib;
+extern crate issue_19340_1 as lib;
use lib::Homura;
bar: T,
}
-impl Trait for int {}
+impl Trait for isize {}
fn main() {
let a = Foo { foo: 12 };
trait Int {
fn one() -> Self;
- fn leading_zeros(self) -> uint;
+ fn leading_zeros(self) -> usize;
}
trait Foo {
// pretty-expanded FIXME #23616
trait Trait {
- fn method(self) -> int;
+ fn method(self) -> isize;
}
struct Wrapper<T> {
}
impl<'a, T> Trait for &'a Wrapper<T> where &'a T: Trait {
- fn method(self) -> int {
+ fn method(self) -> isize {
let r: &'a T = &self.field;
Trait::method(r); // these should both work
r.method()
pub fn main() {
let one = || {
enum r { a };
- r::a as uint
+ r::a as usize
};
let two = || {
enum r { a };
- r::a as uint
+ r::a as usize
};
one(); two();
}
}
#[derive(PartialEq)]
-struct Test(int);
+struct Test(isize);
fn main() {
// Check that ranges implement clone
// pretty-expanded FIXME #23616
fn main() {
- if let Ok(x) = "3.1415".parse() {
+ if let Ok(x) = "3.1415".parse::<f64>() {
assert_eq!(false, x <= 0.0);
}
- if let Ok(x) = "3.1415".parse() {
+ if let Ok(x) = "3.1415".parse::<f64>() {
assert_eq!(3.1415, x + 0.0);
}
- if let Ok(mut x) = "3.1415".parse() {
+ if let Ok(mut x) = "3.1415".parse::<f64>() {
assert_eq!(8.1415, { x += 5.0; x });
}
}
//
// Running /usr/local/bin/rustc:
// issue-2185.rs:24:0: 26:1 error: conflicting implementations for a trait
-// issue-2185.rs:24 impl iterable<uint> for 'static ||uint|| {
-// issue-2185.rs:25 fn iter(&self, blk: |v: uint|) { self( |i| blk(i) ) }
+// issue-2185.rs:24 impl iterable<usize> for 'static ||usize|| {
+// issue-2185.rs:25 fn iter(&self, blk: |v: usize|) { self( |i| blk(i) ) }
// issue-2185.rs:26 }
// issue-2185.rs:20:0: 22:1 note: note conflicting implementation here
// issue-2185.rs:20 impl<A> iterable<A> for 'static ||A|| {
// issue-2185.rs:22 }
//
// … so it looks like it's just not possible to implement both
-// the generic iterable<uint> and iterable<A> for the type iterable<uint>.
+// the generic iterable<usize> and iterable<A> for the type iterable<usize>.
// Is it okay if I just remove this test?
//
// but Niko responded:
fn iter(&self, blk: |A|) { self(blk); }
}
-impl iterable<uint> for 'static ||uint|| {
- fn iter(&self, blk: |v: uint|) { self( |i| blk(i) ) }
+impl iterable<usize> for 'static ||usize|| {
+ fn iter(&self, blk: |v: usize|) { self( |i| blk(i) ) }
}
fn filter<A,IA:iterable<A>>(self: IA, prd: 'static |A| -> bool, blk: |A|) {
b
}
-fn range(lo: uint, hi: uint, it: |uint|) {
+fn range(lo: usize, hi: usize, it: |usize|) {
let mut i = lo;
while i < hi {
it(i);
}
pub fn main() {
- let range: 'static ||uint|| = |a| range(0, 1000, a);
- let filt: 'static ||v: uint|| = |a| filter(
+ let range: 'static ||usize|| = |a| range(0, 1000, a);
+ let filt: 'static ||v: usize|| = |a| filter(
range,
- |&&n: uint| n % 3 != 0 && n % 5 != 0,
+ |&&n: usize| n % 3 != 0 && n % 5 != 0,
a);
- let sum = foldl(filt, 0, |accum, &&n: uint| accum + n );
+ let sum = foldl(filt, 0, |accum, &&n: usize| accum + n );
println!("{}", sum);
}
// pretty-expanded FIXME #23616
-static foo: [uint; 3] = [1, 2, 3];
+static foo: [usize; 3] = [1, 2, 3];
-static slice_1: &'static [uint] = &foo;
-static slice_2: &'static [uint] = &foo;
+static slice_1: &'static [usize] = &foo;
+static slice_2: &'static [usize] = &foo;
fn main() {}
use std::thread::Builder;
use std::thunk::Thunk;
-static generations: uint = 1024+256+128+49;
+static generations: usize = 1024+256+128+49;
fn spawn(f: Thunk<'static>) {
Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(()));
}
-fn child_no(x: uint) -> Thunk<'static> {
+fn child_no(x: usize) -> Thunk<'static> {
Thunk::new(move|| {
if x < generations {
spawn(child_no(x+1));
use std::mem;
use libc::{c_double, c_int};
-fn to_c_int(v: &mut int) -> &mut c_int {
+fn to_c_int(v: &mut isize) -> &mut c_int {
unsafe {
mem::transmute_copy(&v)
}
}
-fn lgamma(n: c_double, value: &mut int) -> c_double {
+fn lgamma(n: c_double, value: &mut isize) -> c_double {
unsafe {
return m::lgamma(n, to_c_int(value));
}
}
pub fn main() {
- let mut y: int = 5;
- let x: &mut int = &mut y;
+ let mut y: isize = 5;
+ let x: &mut isize = &mut y;
assert_eq!(lgamma(1.0 as c_double, x), 0.0 as c_double);
}
pub fn main() {
let c = foo(42);
- let d: Box<clam<int>> = box c as Box<clam<int>>;
+ let d: Box<clam<isize>> = box c as Box<clam<isize>>;
f(d, c.x);
}
trait clam<A> { fn get(self) -> A; }
-struct foo(int);
+struct foo(isize);
impl foo {
pub fn bar<B,C:clam<B>>(&self, _c: C) -> B { panic!(); }
--- /dev/null
+// 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.
+
+// Test for an ICE that occurred when a default method implementation
+// was applied to a type that did not meet the prerequisites. The
+// problem occurred specifically because normalizing
+// `Self::Item::Target` was impossible in this case.
+
+use std::boxed::Box;
+use std::marker::Sized;
+use std::clone::Clone;
+use std::ops::Deref;
+use std::option::Option;
+use std::option::Option::{Some,None};
+
+trait Iterator {
+ type Item;
+
+ fn next(&mut self) -> Option<Self::Item>;
+
+ fn clone_first(mut self) -> Option<<Self::Item as Deref>::Target> where
+ Self: Sized,
+ Self::Item: Deref,
+ <Self::Item as Deref>::Target: Clone,
+ {
+ self.next().map(|x| x.clone())
+ }
+}
+
+struct Counter {
+ value: i32
+}
+
+struct Token {
+ value: i32
+}
+
+impl Iterator for Counter {
+ type Item = Token;
+
+ fn next(&mut self) -> Option<Token> {
+ let x = self.value;
+ self.value += 1;
+ Some(Token { value: x })
+ }
+}
+
+fn main() {
+ let mut x: Box<Iterator<Item=Token>> = Box::new(Counter { value: 22 });
+ assert_eq!(x.next().unwrap().value, 22);
+}
--- /dev/null
+// Copyright 2015 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::fmt;
+
+struct Foo;
+impl fmt::Debug for Foo {
+ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+ println!("<Foo as Debug>::fmt()");
+
+ write!(fmt, "")
+ }
+}
+
+fn test1() {
+ let foo_str = format!("{:?}", Foo);
+
+ println!("{}", foo_str);
+}
+
+fn test2() {
+ println!("{:?}", Foo);
+}
+
+fn main() {
+ // This works fine
+ test1();
+
+ // This fails
+ test2();
+}
pub fn main() {
let _foo = 100;
- const quux: int = 5;
+ const quux: isize = 5;
enum Stuff {
Bar = quux
}
- assert_eq!(Stuff::Bar as int, quux);
+ assert_eq!(Stuff::Bar as isize, quux);
}
}
impl<T> c1<T> {
- pub fn f1(&self, _x: int) {
+ pub fn f1(&self, _x: isize) {
}
}
}
impl<T> c1<T> {
- pub fn f2(&self, _x: int) {
+ pub fn f2(&self, _x: isize) {
}
}
pub fn main() {
- c1::<int>(3).f1(4);
- c1::<int>(3).f2(4);
+ c1::<isize>(3).f1(4);
+ c1::<isize>(3).f2(4);
}
pub fn main() {
- c1::<int>(3).f1(4);
- c1::<int>(3).f2(4);
+ c1::<isize>(3).f1(4);
+ c1::<isize>(3).f2(4);
}
// pretty-expanded FIXME #23616
-struct Pair { f: int, g: int }
+struct Pair { f: isize, g: isize }
pub fn main() {
// pretty-expanded FIXME #23616
struct socket {
- sock: int,
+ sock: isize,
}
fn closure<F>(f: F) where F: FnOnce() { f() }
-fn setsockopt_bytes(_sock: int) { }
+fn setsockopt_bytes(_sock: isize) { }
pub fn main() {}
// pretty-expanded FIXME #23616
struct C {
- x: uint,
+ x: usize,
}
-fn C(x: uint) -> C {
+fn C(x: usize) -> C {
C {
x: x
}
}
struct E {
- f: int
+ f: isize
}
impl A for E {
let v = vec!(Rc::new("hi".to_string()));
let mut m: req::header_map = HashMap::new();
m.insert("METHOD".to_string(), Rc::new(RefCell::new(v)));
- request::<int>(&m);
+ request::<isize>(&m);
}
#![feature(box_syntax)]
-fn a_val(x: Box<int>, y: Box<int>) -> int {
+fn a_val(x: Box<isize>, y: Box<isize>) -> isize {
*x + *y
}
// pretty-expanded FIXME #23616
fn f() {
- let _x: uint = loop { loop { break; } };
+ let _x: usize = loop { loop { break; } };
}
pub fn main() {
#![feature(box_syntax)]
struct Font {
- fontbuf: uint,
- cairo_font: uint,
- font_dtor: uint,
+ fontbuf: usize,
+ cairo_font: usize,
+ font_dtor: usize,
}
#![feature(unsafe_destructor, std_misc)]
-pub type Task = int;
+pub type Task = isize;
// tjc: I don't know why
pub mod pipes {
}
#[derive(PartialEq, Debug)]
- #[repr(int)]
+ #[repr(isize)]
pub enum state {
empty,
full,
}
mod rusti {
- pub fn atomic_xchg(_dst: &mut int, _src: int) -> int { panic!(); }
- pub fn atomic_xchg_acq(_dst: &mut int, _src: int) -> int { panic!(); }
- pub fn atomic_xchg_rel(_dst: &mut int, _src: int) -> int { panic!(); }
+ pub fn atomic_xchg(_dst: &mut isize, _src: isize) -> isize { panic!(); }
+ pub fn atomic_xchg_acq(_dst: &mut isize, _src: isize) -> isize { panic!(); }
+ pub fn atomic_xchg_rel(_dst: &mut isize, _src: isize) -> isize { panic!(); }
}
// We should consider moving this to ::std::unsafe, although I
pub fn swap_state_acq(dst: &mut state, src: state) -> state {
unsafe {
- transmute(rusti::atomic_xchg_acq(transmute(dst), src as int))
+ transmute(rusti::atomic_xchg_acq(transmute(dst), src as isize))
}
}
pub fn swap_state_rel(dst: &mut state, src: state) -> state {
unsafe {
- transmute(rusti::atomic_xchg_rel(transmute(dst), src as int))
+ transmute(rusti::atomic_xchg_rel(transmute(dst), src as isize))
}
}
// pretty-expanded FIXME #23616
-fn thing<'r>(x: &'r [int]) -> &'r [int] { x }
+fn thing<'r>(x: &'r [isize]) -> &'r [isize] { x }
pub fn main() {
let x = &[1,2,3];
use std::collections::HashMap;
-fn add_interfaces(managed_ip: String, device: HashMap<String, int>) {
+fn add_interfaces(managed_ip: String, device: HashMap<String, isize>) {
println!("{}, {}", managed_ip, device["interfaces"]);
}
}
}
-fn add_interface(_store: int, managed_ip: String, data: json::Json) -> (String, object)
+fn add_interface(_store: isize, managed_ip: String, data: json::Json) -> (String, object)
{
match &data {
&Json::Object(ref interface) => {
}
}
-fn add_interfaces(store: int, managed_ip: String, device: HashMap<String, json::Json>)
+fn add_interfaces(store: isize, managed_ip: String, device: HashMap<String, json::Json>)
-> Vec<(String, object)> {
match device["interfaces"] {
Json::Array(ref interfaces) =>
use std::mem;
struct Cat {
- x: int
+ x: isize
}
struct Kitty {
- x: int,
+ x: isize,
}
impl Drop for Kitty {
#[cfg(any(target_arch = "x86_64", target_arch="aarch64"))]
pub fn main() {
- assert_eq!(mem::size_of::<Cat>(), 8 as uint);
- assert_eq!(mem::size_of::<Kitty>(), 16 as uint);
+ assert_eq!(mem::size_of::<Cat>(), 8 as usize);
+ assert_eq!(mem::size_of::<Kitty>(), 16 as usize);
}
#[cfg(any(target_arch = "x86", target_arch = "arm"))]
pub fn main() {
- assert_eq!(mem::size_of::<Cat>(), 4 as uint);
- assert_eq!(mem::size_of::<Kitty>(), 8 as uint);
+ assert_eq!(mem::size_of::<Cat>(), 4 as usize);
+ assert_eq!(mem::size_of::<Kitty>(), 8 as usize);
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-//type t = { a: int };
+//type t = { a: isize };
// type t = { a: bool };
type t = bool;
}
struct cbar {
- x: int,
+ x: isize,
}
-impl bar<int> for cbar {
- fn get_bar(&self) -> int {
+impl bar<isize> for cbar {
+ fn get_bar(&self) -> isize {
self.x
}
}
-fn cbar(x: int) -> cbar {
+fn cbar(x: isize) -> cbar {
cbar {
x: x
}
}
pub fn main() {
- let x: int = foo::<int, cbar>(cbar(5));
+ let x: isize = foo::<isize, cbar>(cbar(5));
assert_eq!(x, 5);
}
pub fn main() {
let x: Box<_>;
- let mut buggy_map: HashMap<uint, &uint> = HashMap::new();
+ let mut buggy_map: HashMap<usize, &usize> = HashMap::new();
x = box 1;
buggy_map.insert(42, &*x);
}
// pretty-expanded FIXME #23616
-struct thing { x: int, }
+struct thing { x: isize, }
impl Drop for thing {
fn drop(&mut self) {}
#![allow(unknown_features)]
#![feature(unboxed_closures, old_path, std_misc)]
-use std::old_path::{Path};
+use std::old_path::Path;
use std::old_path;
use std::result;
use std::thunk::Thunk;
// pretty-expanded FIXME #23616
trait Canvas {
- fn add_point(&self, point: &int);
- fn add_points(&self, shapes: &[int]) {
+ fn add_point(&self, point: &isize);
+ fn add_points(&self, shapes: &[isize]) {
for pt in shapes {
self.add_point(pt)
}
// Represents a position on a canvas.
#[derive(Copy)]
struct Point {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
// Represents an offset on a canvas. (This has the same structure as a Point.
// but different semantics).
#[derive(Copy)]
struct Size {
- width: int,
- height: int,
+ width: isize,
+ height: isize,
}
#[derive(Copy)]
// Contains the information needed to do shape rendering via ASCII art.
struct AsciiArt {
- width: uint,
- height: uint,
+ width: usize,
+ height: usize,
fill: char,
lines: Vec<Vec<char> > ,
// It's common to define a constructor sort of function to create struct instances.
// If there is a canonical constructor it is typically named the same as the type.
// Other constructor sort of functions are typically named from_foo, from_bar, etc.
-fn AsciiArt(width: uint, height: uint, fill: char) -> AsciiArt {
+fn AsciiArt(width: usize, height: usize, fill: char) -> AsciiArt {
// Use an anonymous function to build a vector of vectors containing
// blank characters for each position in our canvas.
let mut lines = Vec::new();
// Methods particular to the AsciiArt struct.
impl AsciiArt {
- fn add_pt(&mut self, x: int, y: int) {
- if x >= 0 && x < self.width as int {
- if y >= 0 && y < self.height as int {
+ fn add_pt(&mut self, x: isize, y: isize) {
+ if x >= 0 && x < self.width as isize {
+ if y >= 0 && y < self.height as isize {
// Note that numeric types don't implicitly convert to each other.
- let v = y as uint;
- let h = x as uint;
+ let v = y as usize;
+ let h = x as usize;
// Vector subscripting will normally copy the element, but &v[i]
// will return a reference which is what we need because the
trait Foo {
- fn a(&self) -> int;
- fn b(&self) -> int {
+ fn a(&self) -> isize;
+ fn b(&self) -> isize {
self.a() + 2
}
}
-impl Foo for int {
- fn a(&self) -> int {
+impl Foo for isize {
+ fn a(&self) -> isize {
3
}
}
#[derive(Debug)]
struct S {
- s: int,
+ s: isize,
}
impl T for S {
// except according to those terms.
mod buildings {
- pub struct Tower { pub height: uint }
+ pub struct Tower { pub height: usize }
}
pub fn main() {
let sears = buildings::Tower { height: 1451 };
- let h: uint = match sears {
+ let h: usize = match sears {
buildings::Tower { height: h } => { h }
};
// pretty-expanded FIXME #23616
-enum PureCounter { PureCounterVariant(uint) }
+enum PureCounter { PureCounterVariant(usize) }
-fn each<F>(thing: PureCounter, blk: F) where F: FnOnce(&uint) {
+fn each<F>(thing: PureCounter, blk: F) where F: FnOnce(&usize) {
let PureCounter::PureCounterVariant(ref x) = thing;
blk(x);
}
}
}
-struct Point { x: int, y: int }
+struct Point { x: isize, y: isize }
-impl Positioned<int> for Point {
- fn SetX(&mut self, x: int) {
+impl Positioned<isize> for Point {
+ fn SetX(&mut self, x: isize) {
self.x = x;
}
- fn X(&self) -> int {
+ fn X(&self) -> isize {
self.x
}
}
-impl Movable<int> for Point {}
+impl Movable<isize> for Point {}
pub fn main() {
let mut p = Point{ x: 1, y: 2};
extern crate issue_3979_traits;
use issue_3979_traits::{Positioned, Movable};
-struct Point { x: int, y: int }
+struct Point { x: isize, y: isize }
impl Positioned for Point {
- fn SetX(&mut self, x: int) {
+ fn SetX(&mut self, x: isize) {
self.x = x;
}
- fn X(&self) -> int {
+ fn X(&self) -> isize {
self.x
}
}
// pretty-expanded FIXME #23616
trait Positioned {
- fn SetX(&mut self, int);
- fn X(&self) -> int;
+ fn SetX(&mut self, isize);
+ fn X(&self) -> isize;
}
trait Movable: Positioned {
- fn translate(&mut self, dx: int) {
+ fn translate(&mut self, dx: isize) {
let x = self.X();
self.SetX(x + dx);
}
}
-struct Point { x: int, y: int }
+struct Point { x: isize, y: isize }
impl Positioned for Point {
- fn SetX(&mut self, x: int) {
+ fn SetX(&mut self, x: isize) {
self.x = x;
}
- fn X(&self) -> int {
+ fn X(&self) -> isize {
self.x
}
}
// pretty-expanded FIXME #23616
struct HasNested {
- nest: Vec<Vec<int> > ,
+ nest: Vec<Vec<isize> > ,
}
impl HasNested {
pub fn main() {
let json = json::from_str("[1]").unwrap();
let mut decoder = json::Decoder::new(json);
- let _x: Vec<int> = Decodable::decode(&mut decoder).unwrap();
+ let _x: Vec<isize> = Decodable::decode(&mut decoder).unwrap();
}
}
pub trait Index<Index,Result> { fn get(&self, Index) -> Result { panic!() } }
-pub trait Dimensional<T>: Index<uint, T> { }
+pub trait Dimensional<T>: Index<usize, T> { }
pub struct Mat2<T> { x: T }
pub struct Vec2<T> { x: T }
impl<T> Dimensional<Vec2<T>> for Mat2<T> { }
-impl<T> Index<uint, Vec2<T>> for Mat2<T> { }
+impl<T> Index<usize, Vec2<T>> for Mat2<T> { }
impl<T> Dimensional<T> for Vec2<T> { }
-impl<T> Index<uint, T> for Vec2<T> { }
+impl<T> Index<usize, T> for Vec2<T> { }
pub trait Matrix<T,V>: Dimensional<V> {
fn identity(t:T) -> Self;
use extra::net::tcp::TcpSocketBuf;
use std::io;
-use std::int;
+use std::isize;
use std::io::{ReaderUtil,WriterUtil};
enum Result {
Nil,
- Int(int),
+ Int(isize),
Data(~[u8]),
List(~[Result]),
Error(String),
Status(String)
}
-priv fn parse_data(len: uint, io: @io::Reader) -> Result {
+priv fn parse_data(len: usize, io: @io::Reader) -> Result {
let res =
if (len > 0) {
- let bytes = io.read_bytes(len as uint);
+ let bytes = io.read_bytes(len as usize);
assert_eq!(bytes.len(), len);
Data(bytes)
} else {
return res;
}
-priv fn parse_list(len: uint, io: @io::Reader) -> Result {
+priv fn parse_list(len: usize, io: @io::Reader) -> Result {
let mut list: ~[Result] = ~[];
for _ in 0..len {
let v = match io.read_char() {
}
priv fn parse_bulk(io: @io::Reader) -> Result {
- match from_str::<int>(chop(io.read_line())) {
+ match from_str::<isize>(chop(io.read_line())) {
None => panic!(),
Some(-1) => Nil,
- Some(len) if len >= 0 => parse_data(len as uint, io),
+ Some(len) if len >= 0 => parse_data(len as usize, io),
Some(_) => panic!()
}
}
priv fn parse_multi(io: @io::Reader) -> Result {
- match from_str::<int>(chop(io.read_line())) {
+ match from_str::<isize>(chop(io.read_line())) {
None => panic!(),
Some(-1) => Nil,
Some(0) => List(~[]),
- Some(len) if len >= 0 => parse_list(len as uint, io),
+ Some(len) if len >= 0 => parse_list(len as usize, io),
Some(_) => panic!()
}
}
priv fn parse_int(io: @io::Reader) -> Result {
- match from_str::<int>(chop(io.read_line())) {
+ match from_str::<isize>(chop(io.read_line())) {
None => panic!(),
Some(i) => Int(i)
}
}
#[derive(Debug)]
-struct Y(int);
+struct Y(isize);
#[derive(Debug)]
struct Z<T: X+std::fmt::Debug> {
// pretty-expanded FIXME #23616
-fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { &v[i..j] }
+fn broken(v: &[u8], i: usize, j: usize) -> &[u8] { &v[i..j] }
pub fn main() {}
// pretty-expanded FIXME #23616
-extern crate "issue-4545" as somelib;
-pub fn main() { somelib::mk::<int>(); }
+extern crate issue_4545 as somelib;
+pub fn main() { somelib::mk::<isize>(); }
#![allow(path_statement)]
-struct A { n: int }
+struct A { n: isize }
struct B;
-static mut NUM_DROPS: uint = 0;
+static mut NUM_DROPS: usize = 0;
impl Drop for A {
fn drop(&mut self) {
impl Drop for NonCopyable {
fn drop(&mut self) {
let NonCopyable(p) = *self;
- let _v = unsafe { transmute::<*const c_void, Box<int>>(p) };
+ let _v = unsafe { transmute::<*const c_void, Box<isize>>(p) };
}
}
pub fn main() {
let t = box 0;
- let p = unsafe { transmute::<Box<int>, *const c_void>(t) };
+ let p = unsafe { transmute::<Box<isize>, *const c_void>(t) };
let _z = NonCopyable(p);
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct T { a: Box<int> }
+struct T { a: Box<isize> }
trait U {
fn f(self);
}
-impl U for Box<int> {
+impl U for Box<isize> {
fn f(self) { }
}
pub struct Scheduler {
/// The event loop used to drive the scheduler and perform I/O
- event_loop: Box<int>
+ event_loop: Box<isize>
}
pub fn main() { }
}
pub struct UvEventLoop {
- uvio: int
+ uvio: isize
}
impl UvEventLoop {
// pretty-expanded FIXME #23616
pub fn main() {
- let _f = |ref x: int| { *x };
+ let _f = |ref x: isize| { *x };
let foo = 10;
assert!(_f(foo) == 10);
}
// pretty-expanded FIXME #23616
struct S<'a> {
- v: &'a int
+ v: &'a isize
}
fn f<'lt>(_s: &'lt S<'lt>) {}
fn yes(self);
}
-impl Fooable for uint {
+impl Fooable for usize {
fn yes(self) {
for _ in 0..self { println!("yes"); }
}
// pretty-expanded FIXME #23616
-extern crate "issue-5518" as other;
+extern crate issue_5518 as other;
fn main() {}
// pretty-expanded FIXME #23616
-extern crate "issue-5521" as foo;
+extern crate issue_5521 as foo;
fn bar(a: foo::map) {
if false {
// pretty-expanded FIXME #23616
enum Enum {
- Foo { foo: uint },
- Bar { bar: uint }
+ Foo { foo: usize },
+ Bar { bar: usize }
}
-fn fun1(e1: &Enum, e2: &Enum) -> uint {
+fn fun1(e1: &Enum, e2: &Enum) -> usize {
match (e1, e2) {
(&Enum::Foo { foo: _ }, &Enum::Foo { foo: _ }) => 0,
(&Enum::Foo { foo: _ }, &Enum::Bar { bar: _ }) => 1,
}
}
-fn fun2(e1: &Enum, e2: &Enum) -> uint {
+fn fun2(e1: &Enum, e2: &Enum) -> usize {
match (e1, e2) {
(&Enum::Foo { foo: _ }, &Enum::Foo { foo: _ }) => 0,
(&Enum::Foo { foo: _ }, _ ) => 1,
macro_rules! constants {
() => {
- let _ : X<int> = Default::default();
+ let _ : X<isize> = Default::default();
}
}
...should print &[1, 2, 3] but instead prints something like
&[4492532864, 24]. It is pretty evident that the compiler messed up
-with the representation of [int; n] and [int] somehow, or at least
+with the representation of [isize; n] and [isize] somehow, or at least
failed to typecheck correctly.
*/
#[derive(Copy)]
-struct X { vec: &'static [int] }
+struct X { vec: &'static [isize] }
static V: &'static [X] = &[X { vec: &[1, 2, 3] }];
fn print(&self);
}
-impl Inner for int {
+impl Inner for isize {
fn print(&self) { print!("Inner: {}\n", *self); }
}
}
pub fn main() {
- let inner: int = 5;
+ let inner: isize = 5;
let outer = Outer::new(&inner as &Inner);
outer.inner.print();
}
if $tag == $string {
let element: Box<_> = box Element;
unsafe {
- return std::mem::transmute::<_, uint>(element);
+ return std::mem::transmute::<_, usize>(element);
}
}
}
}
-fn bar() -> uint {
+fn bar() -> usize {
foo!("a", "b");
0
}
#![feature(box_syntax)]
pub struct Foo {
- a: int,
+ a: isize,
}
struct Bar<'a> {
- a: Box<Option<int>>,
+ a: Box<Option<isize>>,
b: &'a Foo,
}
}
pub enum Bar {
- Bar0 = 0 as int
+ Bar0 = 0 as isize
}
pub fn main() {}
// pretty-expanded FIXME #23616
-struct T (&'static [int]);
+struct T (&'static [isize]);
static t : T = T (&[5, 4, 3]);
pub fn main () {
let T(ref v) = t;
}
fn main() {
- let b = f::<int>();
+ let b = f::<isize>();
assert!(b);
}
}
-impl<E> Graph<int, E> for HashMap<int, int> {
+impl<E> Graph<isize, E> for HashMap<isize, isize> {
fn f(&self, _e: E) {
panic!();
}
- fn g(&self, _e: int) {
+ fn g(&self, _e: isize) {
panic!();
}
}
pub fn main() {
- let g : Box<HashMap<int,int>> = box HashMap::new();
- let _g2 : Box<Graph<int,int>> = g as Box<Graph<int,int>>;
+ let g : Box<HashMap<isize,isize>> = box HashMap::new();
+ let _g2 : Box<Graph<isize,isize>> = g as Box<Graph<isize,isize>>;
}
#![deny(type_limits)]
pub fn main() {
- let i: uint = 0;
+ let i: usize = 0;
assert!(i <= 0xFFFF_FFFF);
- let i: int = 0;
+ let i: isize = 0;
assert!(i >= -0x8000_0000);
assert!(i <= 0x7FFF_FFFF);
}
// pretty-expanded FIXME #23616
-fn swap<F>(f: F) -> Vec<int> where F: FnOnce(Vec<int>) -> Vec<int> {
+fn swap<F>(f: F) -> Vec<isize> where F: FnOnce(Vec<isize>) -> Vec<isize> {
let x = vec!(1, 2, 3);
f(x)
}
// pretty-expanded FIXME #23616
-pub trait OpInt { fn call(&mut self, int, int) -> int; }
+pub trait OpInt { fn call(&mut self, isize, isize) -> isize; }
-impl<F> OpInt for F where F: FnMut(int, int) -> int {
- fn call(&mut self, a:int, b:int) -> int {
+impl<F> OpInt for F where F: FnMut(isize, isize) -> isize {
+ fn call(&mut self, a:isize, b:isize) -> isize {
(*self)(a, b)
}
}
-fn squarei<'a>(x: int, op: &'a mut OpInt) -> int { op.call(x, x) }
+fn squarei<'a>(x: isize, op: &'a mut OpInt) -> isize { op.call(x, x) }
-fn muli(x:int, y:int) -> int { x * y }
+fn muli(x:isize, y:isize) -> isize { x * y }
pub fn main() {
let mut f = |x, y| muli(x, y);
// pretty-expanded FIXME #23616
trait A {
- fn a(&self) -> uint;
+ fn a(&self) -> usize;
}
trait B {
- fn b(&self) -> uint;
+ fn b(&self) -> usize;
}
trait C {
- fn combine<T:A+B>(&self, t: &T) -> uint;
+ fn combine<T:A+B>(&self, t: &T) -> usize;
}
struct Foo;
impl A for Foo {
- fn a(&self) -> uint { 1 }
+ fn a(&self) -> usize { 1 }
}
impl B for Foo {
- fn b(&self) -> uint { 2 }
+ fn b(&self) -> usize { 2 }
}
struct Bar;
impl C for Bar {
// Note below: bounds in impl decl are in reverse order.
- fn combine<T:B+A>(&self, t: &T) -> uint {
+ fn combine<T:B+A>(&self, t: &T) -> usize {
(t.a() * 100) + t.b()
}
}
-fn use_c<S:C, T:B+A>(s: &S, t: &T) -> uint {
+fn use_c<S:C, T:B+A>(s: &S, t: &T) -> usize {
s.combine(t)
}
// pretty-expanded FIXME #23616
#[derive(PartialEq)]
-struct A { x: uint }
+struct A { x: usize }
impl Drop for A {
fn drop(&mut self) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct A { x: uint }
+struct A { x: usize }
impl Drop for A {
fn drop(&mut self) {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct A { x: uint }
+struct A { x: usize }
impl Drop for A {
fn drop(&mut self) {}
// pretty-expanded FIXME #23616
enum Foo {
- Bar(int),
+ Bar(isize),
Baz,
}
pub mod Bar {
pub struct Foo {
- v: int,
+ v: isize,
}
extern {
#![feature(box_patterns)]
#![feature(box_syntax)]
-fn foo(box (_x, _y): Box<(int, int)>) {}
+fn foo(box (_x, _y): Box<(isize, isize)>) {}
pub fn main() {}
// pretty-expanded FIXME #23616
struct Foo;
-struct Bar { x: int }
-struct Baz(int);
-enum FooBar { _Foo(Foo), _Bar(uint) }
+struct Bar { x: isize }
+struct Baz(isize);
+enum FooBar { _Foo(Foo), _Bar(usize) }
-static mut NUM_DROPS: uint = 0;
+static mut NUM_DROPS: usize = 0;
impl Drop for Foo {
fn drop(&mut self) {
use std::intrinsics;
/// Returns the size of a type
-pub fn size_of<T>() -> uint {
+pub fn size_of<T>() -> usize {
TypeInfo::size_of(None::<T>)
}
/// Returns the size of the type that `val` points to
-pub fn size_of_val<T>(val: &T) -> uint {
+pub fn size_of_val<T>(val: &T) -> usize {
val.size_of_val()
}
pub trait TypeInfo {
- fn size_of(_lame_type_hint: Option<Self>) -> uint;
- fn size_of_val(&self) -> uint;
+ fn size_of(_lame_type_hint: Option<Self>) -> usize;
+ fn size_of_val(&self) -> usize;
}
impl<T> TypeInfo for T {
/// The size of the type in bytes.
- fn size_of(_lame_type_hint: Option<T>) -> uint {
+ fn size_of(_lame_type_hint: Option<T>) -> usize {
unsafe { intrinsics::size_of::<T>() }
}
/// Returns the size of the type of `self` in bytes.
- fn size_of_val(&self) -> uint {
+ fn size_of_val(&self) -> usize {
TypeInfo::size_of(None::<T>)
}
}
// pretty-expanded FIXME #23616
-extern crate "issue-7178" as cross_crate_self;
+extern crate issue_7178 as cross_crate_self;
pub fn main() {
let _ = cross_crate_self::Foo::new(&1);
}
#[derive(Debug)]
-struct A { a: int }
+struct A { a: isize }
#[derive(Debug)]
-struct B<'a> { b: int, pa: &'a A }
+struct B<'a> { b: isize, pa: &'a A }
impl IDummy for A {
fn do_nothing(&self) {
fn new(&self) -> bool { true }
}
-impl Bar for int {}
-impl Foo for int {}
+impl Bar for isize {}
+impl Foo for isize {}
fn main() {
assert!(1.new());
use std::collections::HashMap;
-struct A(int, int);
+struct A(isize, isize);
pub fn main() {
- let mut m: HashMap<int, A> = HashMap::new();
+ let mut m: HashMap<isize, A> = HashMap::new();
m.insert(1, A(0, 0));
let A(ref _a, ref _b) = m[&1];
mod test1 {
- mod foo { pub fn p() -> int { 1 } }
- mod bar { pub fn p() -> int { 2 } }
+ mod foo { pub fn p() -> isize { 1 } }
+ mod bar { pub fn p() -> isize { 2 } }
pub mod baz {
use test1::bar::p;
mod test2 {
- mod foo { pub fn p() -> int { 1 } }
- mod bar { pub fn p() -> int { 2 } }
+ mod foo { pub fn p() -> isize { 1 } }
+ mod bar { pub fn p() -> isize { 2 } }
pub mod baz {
use test2::bar::p;
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
use std::ops::Add;
// pretty-expanded FIXME #23616
-extern crate "issue-7899" as testcrate;
+extern crate issue_7899 as testcrate;
fn main() {
let f = testcrate::V2(1.0f32, 2.0f32);
// pretty-expanded FIXME #23616
-extern crate "issue-8044" as minimal;
+extern crate issue_8044 as minimal;
use minimal::{BTree, leaf};
pub fn main() {
- BTree::<int> { node: leaf(1) };
+ BTree::<isize> { node: leaf(1) };
}
// pretty-expanded FIXME #23616
-extern crate "issue-8259" as other;
+extern crate issue_8259 as other;
static a: other::Foo<'static> = other::Foo::A;
pub fn main() {}
// pretty-expanded FIXME #23616
enum E {
- Foo{f: int},
+ Foo{f: isize},
Bar,
}
// pretty-expanded FIXME #23616
enum E {
- Foo{f: int, b: bool},
+ Foo{f: isize, b: bool},
Bar,
}
assert!(thread::spawn(move|| { min_val::<i16>() / -1; }).join().is_err());
assert!(thread::spawn(move|| { min_val::<i32>() / -1; }).join().is_err());
assert!(thread::spawn(move|| { min_val::<i64>() / -1; }).join().is_err());
- assert!(thread::spawn(move|| { 1isize / zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i8 / zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i16 / zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i32 / zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i64 / zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1isize / zero::<isize>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i8 / zero::<i8>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i16 / zero::<i16>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i32 / zero::<i32>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i64 / zero::<i64>(); }).join().is_err());
assert!(thread::spawn(move|| { min_val::<isize>() % -1; }).join().is_err());
assert!(thread::spawn(move|| { min_val::<i8>() % -1; }).join().is_err());
assert!(thread::spawn(move|| { min_val::<i16>() % -1; }).join().is_err());
assert!(thread::spawn(move|| { min_val::<i32>() % -1; }).join().is_err());
assert!(thread::spawn(move|| { min_val::<i64>() % -1; }).join().is_err());
- assert!(thread::spawn(move|| { 1isize % zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i8 % zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i16 % zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i32 % zero(); }).join().is_err());
- assert!(thread::spawn(move|| { 1i64 % zero(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1isize % zero::<isize>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i8 % zero::<i8>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i16 % zero::<i16>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i32 % zero::<i32>(); }).join().is_err());
+ assert!(thread::spawn(move|| { 1i64 % zero::<i64>(); }).join().is_err());
}
}
fn main() {
- assert_eq!(sty!(int), "int");
+ assert_eq!(sty!(isize), "isize");
assert_eq!(spath!(std::option), "std::option");
}
use std::default::Default;
-struct X { pub x: uint }
+struct X { pub x: usize }
impl Default for X {
fn default() -> X {
X { x: 42 }
use std::thread::Thread;
use std::sync::mpsc::{channel, Receiver};
-fn periodical(n: int) -> Receiver<bool> {
+fn periodical(n: isize) -> Receiver<bool> {
let (chan, port) = channel();
Thread::spawn(move|| {
loop {
return port;
}
-fn integers() -> Receiver<int> {
+fn integers() -> Receiver<isize> {
let (chan, port) = channel();
Thread::spawn(move|| {
let mut i = 1;
// pretty-expanded FIXME #23616
enum T {
- A(int),
- B(uint)
+ A(isize),
+ B(usize)
}
macro_rules! test {
($id:ident, $e:expr) => (
- fn foo(t: T) -> int {
+ fn foo(t: T) -> isize {
match t {
T::A($id) => $e,
T::B($id) => $e
)
}
-test!(y, 10 + (y as int));
+test!(y, 10 + (y as isize));
pub fn main() {
foo(T::A(20));
// pretty-expanded FIXME #23616
-static mut DROP: int = 0;
-static mut DROP_S: int = 0;
-static mut DROP_T: int = 0;
+static mut DROP: isize = 0;
+static mut DROP_S: isize = 0;
+static mut DROP_T: isize = 0;
struct S;
impl Drop for S {
}
fn f(ref _s: S) {}
-struct T { i: int }
+struct T { i: isize }
impl Drop for T {
fn drop(&mut self) {
unsafe {
fn decode() -> String {
'outer: loop {
- let mut ch_start: uint;
+ let mut ch_start: usize;
break 'outer;
}
"".to_string()
pub struct S;
impl bomb for S { fn boom(&self, _: Ident) { } }
-pub struct Ident { name: uint }
+pub struct Ident { name: usize }
// macro_rules! int3 { () => ( unsafe { asm!( "int3" ); } ) }
macro_rules! int3 { () => ( { } ) }
pub fn main() {
let a = issue_9188::bar();
- let b = issue_9188::foo::<int>();
+ let b = issue_9188::foo::<isize>();
assert_eq!(*a, *b);
}
struct Thing1<'a> {
- baz: &'a [Box<int>],
+ baz: &'a [Box<isize>],
bar: Box<u64>,
}
struct Thing2<'a> {
- baz: &'a [Box<int>],
+ baz: &'a [Box<isize>],
bar: u64,
}
pub trait X {
fn dummy(&self) { }
}
- impl X for int {}
+ impl X for isize {}
pub struct Z<'a>(Enum<&'a (X+'a)>);
- fn foo() { let x: int = 42; let z = Z(Enum::A(&x as &X)); let _ = z; }
+ fn foo() { let x: isize = 42; let z = Z(Enum::A(&x as &X)); let _ = z; }
}
mod b {
trait X {
fn dummy(&self) { }
}
- impl X for int {}
+ impl X for isize {}
struct Y<'a>{
x:Option<&'a (X+'a)>,
}
fn bar() {
- let x: int = 42;
+ let x: isize = 42;
let _y = Y { x: Some(&x as &X) };
}
}
mod c {
pub trait X { fn f(&self); }
- impl X for int { fn f(&self) {} }
+ impl X for isize { fn f(&self) {} }
pub struct Z<'a>(Option<&'a (X+'a)>);
- fn main() { let x: int = 42; let z = Z(Some(&x as &X)); let _ = z; }
+ fn main() { let x: isize = 42; let z = Z(Some(&x as &X)); let _ = z; }
}
pub fn main() {}
use std::cell::Cell;
struct r<'a> {
- b: &'a Cell<int>,
+ b: &'a Cell<isize>,
}
#[unsafe_destructor]
}
}
-fn r(b: &Cell<int>) -> r {
+fn r(b: &Cell<isize>) -> r {
r {
b: b
}
// pretty-expanded FIXME #23616
-extern crate "issue-9906" as testmod;
+extern crate issue_9906 as testmod;
pub fn main() {
testmod::foo();
// pretty-expanded FIXME #23616
pub fn main() {
- const S: uint = 23 as uint; [0; S]; ()
+ const S: usize = 23 as usize; [0; S]; ()
}
// pretty-expanded FIXME #23616
-extern crate "issue-9968" as lib;
+extern crate issue_9968 as lib;
use lib::{Trait, Struct};
mod test_single_attr_outer {
#[attr = "val"]
- pub static x: int = 10;
+ pub static x: isize = 10;
#[attr = "val"]
pub fn f() { }
mod test_multi_attr_outer {
#[attr1 = "val"]
#[attr2 = "val"]
- pub static x: int = 10;
+ pub static x: isize = 10;
#[attr1 = "val"]
#[attr2 = "val"]
#[attr1 = "val"]
#[attr2 = "val"]
- struct t {x: int}
+ struct t {x: isize}
}
mod test_stmt_single_attr_outer {
pub fn f() {
#[attr = "val"]
- static x: int = 10;
+ static x: isize = 10;
#[attr = "val"]
fn f() { }
#[attr1 = "val"]
#[attr2 = "val"]
- static x: int = 10;
+ static x: isize = 10;
#[attr1 = "val"]
#[attr2 = "val"]
/*mod test_literals {
#![str = "s"]
#![char = 'c']
- #![int = 100]
- #![uint = 100_usize]
+ #![isize = 100]
+ #![usize = 100_usize]
#![mach_int = 100u32]
#![float = 1.0]
#![mach_float = 1.0f32]
-fn range_<F>(a: int, b: int, mut it: F) where F: FnMut(int) {
+fn range_<F>(a: isize, b: isize, mut it: F) where F: FnMut(isize) {
assert!((a < b));
- let mut i: int = a;
+ let mut i: isize = a;
while i < b { it(i); i += 1; }
}
pub fn main() {
- let mut sum: int = 0;
+ let mut sum: isize = 0;
range_(0, 100, |x| sum += x );
println!("{}", sum);
}
// pretty-expanded FIXME #23616
-fn f(_a: Vec<int> ) { }
+fn f(_a: Vec<isize> ) { }
pub fn main() { f(vec!(1, 2, 3, 4, 5)); }
mod foo {
}
-fn bar() -> int {
+fn bar() -> isize {
match 0 {
_ => { 0 }
}
use std::thread::Thread;
-fn user(_i: int) {}
+fn user(_i: isize) {}
fn foo() {
// Here, i is *copied* into the proc (heap closure).
use kinds_in_metadata::f;
pub fn main() {
- f::<int>();
+ f::<isize>();
}
// resolved when we finish typechecking the ||.
-struct Refs { refs: Vec<int> , n: int }
+struct Refs { refs: Vec<isize> , n: isize }
pub fn main() {
let mut e = Refs{refs: vec!(), n: 0};
let _f = || println!("{}", e.n);
- let x: &[int] = &e.refs;
+ let x: &[isize] = &e.refs;
assert_eq!(x.len(), 0);
}
($ex:expr) => ({(|_x| { $ex }) (9) })
}
-fn takes_x(_x : int) {
+fn takes_x(_x : isize) {
assert_eq!(bad_macro!(_x),8);
}
fn main() {
#![feature(lang_items, start, no_std)]
#![no_std]
-extern crate "lang-item-public" as lang_lib;
+extern crate lang_item_public as lang_lib;
#[cfg(target_os = "linux")]
#[link(name = "c")]
extern {}
#[start]
-fn main(_: int, _: *const *const u8) -> int {
- 1 % 1
+fn main(_: isize, _: *const *const u8) -> isize {
+ 1_isize % 1_isize
}
// pretty-expanded FIXME #23616
-struct Large {a: int,
- b: int,
- c: int,
- d: int,
- e: int,
- f: int,
- g: int,
- h: int,
- i: int,
- j: int,
- k: int,
- l: int}
+struct Large {a: isize,
+ b: isize,
+ c: isize,
+ d: isize,
+ e: isize,
+ f: isize,
+ g: isize,
+ h: isize,
+ i: isize,
+ j: isize,
+ k: isize,
+ l: isize}
fn f() {
let _foo: Large =
Large {a: 0,
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct A { a: Box<int> }
+struct A { a: Box<isize> }
pub fn main() {
fn invoke<F>(f: F) where F: FnOnce() { f(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }
+fn incr(x: &mut isize) -> bool { *x += 1; assert!((false)); return false; }
pub fn main() {
let x = 1 == 2 || 3 == 3;
assert!((x));
- let mut y: int = 10;
+ let mut y: isize = 10;
println!("{}", x || incr(&mut y));
assert_eq!(y, 10);
if true && x { assert!((true)); } else { assert!((false)); }
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
-pub fn main() { let mut x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }
+pub fn main() { let mut x: isize; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }
fn leaky<T>(_t: T) { }
-pub fn main() { let x = box 10; leaky::<Box<int>>(x); }
+pub fn main() { let x = box 10; leaky::<Box<isize>>(x); }
fn f() {
let a: Box<_> = box 1;
- let b: &int = &*a;
+ let b: &isize = &*a;
println!("{}", b);
}
println!("{}", y);
assert_eq!(y, 6);
let s = "hello there".to_string();
- let mut i: int = 0;
+ let mut i: isize = 0;
for c in s.bytes() {
if i == 0 { assert!((c == 'h' as u8)); }
if i == 1 { assert!((c == 'e' as u8)); }
#[cfg(not(target_os = "macos"))]
#[link_section=".imm"]
-static magic: uint = 42;
+static magic: usize = 42;
#[cfg(not(target_os = "macos"))]
#[link_section=".mut"]
-static mut frobulator: uint = 0xdeadbeef;
+static mut frobulator: usize = 0xdeadbeef;
#[cfg(target_os = "macos")]
#[link_section="__TEXT,__moretext"]
#[cfg(target_os = "macos")]
#[link_section="__RODATA,__imm"]
-static magic: uint = 42;
+static magic: usize = 42;
#[cfg(target_os = "macos")]
#[link_section="__DATA,__mut"]
-static mut frobulator: uint = 0xdeadbeef;
+static mut frobulator: usize = 0xdeadbeef;
pub fn main() {
unsafe {
#![feature(std_misc, old_path)]
-extern crate "linkage-visibility" as foo;
+extern crate linkage_visibility as foo;
pub fn main() {
foo::test();
- foo::foo2::<int>();
+ foo::foo2::<isize>();
foo::foo();
}
#![feature(linkage)]
-extern crate "linkage1" as other;
+extern crate linkage1 as other;
extern {
#[linkage = "extern_weak"]
- static foo: *const int;
+ static foo: *const isize;
#[linkage = "extern_weak"]
- static something_that_should_never_exist: *mut int;
+ static something_that_should_never_exist: *mut isize;
}
fn main() {
struct ヒ;
-static ラ: uint = 0;
+static ラ: usize = 0;
pub fn main() {}
// pretty-expanded FIXME #23616
#[forbid(non_camel_case_types)]
-type Foo_ = int;
+type Foo_ = isize;
pub fn main() { }
#![forbid(non_camel_case_types)]
#![forbid(non_upper_case_globals)]
-static mut bar: int = 2;
+static mut bar: isize = 2;
pub fn main() {}
#![allow(unknown_features)]
#![feature(box_syntax)]
-enum list { cons(int, Box<list>), nil, }
+enum list { cons(isize, Box<list>), nil, }
pub fn main() { list::cons(10, box list::cons(11, box list::cons(12, box list::nil))); }
#![allow(unused_variable)]
fn test(_cond: bool) {
- let v: int;
+ let v: isize;
v = 1;
loop { } // loop never terminates, so no error is reported
v = 2;
#![allow(unreachable_code)]
fn test() {
- let _v: int;
+ let _v: isize;
_v = 1;
return;
_v = 2; //~ WARNING: unreachable statement
// pretty-expanded FIXME #23616
-fn take(x: int) -> int {x}
+fn take(x: isize) -> isize {x}
fn the_loop() {
let mut list = Vec::new();
#[derive(Clone, Debug)]
enum foo {
- a(uint),
+ a(usize),
b(String),
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// exec-env:RUST_LOG=logging-enabled=info
+// exec-env:RUST_LOG=logging_enabled=info
// pretty-expanded FIXME #23616
use std::fmt;
use std::thread;
-struct Foo(Cell<int>);
+struct Foo(Cell<isize>);
impl fmt::Debug for Foo {
fn fmt(&self, _fmt: &mut fmt::Formatter) -> fmt::Result {
pub fn main() {
// this function panicks if logging is turned on
- logging_right_crate::foo::<int>();
+ logging_right_crate::foo::<isize>();
}
#![allow(unused_variable)]
pub fn main() {
- let mut i: int = 0;
+ let mut i: isize = 0;
while i < 1000000 {
i += 1;
let x = 3;
macro_rules! mylambda_tt {
($x:ident, $body:expr) => ({
- fn f($x: int) -> int { return $body; };
+ fn f($x: isize) -> isize { return $body; };
f
})
}
// ignore-stage1
#[macro_use]
-extern crate "macro_crate_nonterminal" as new_name;
+extern crate macro_crate_nonterminal as new_name;
pub fn main() {
new_name::check_local();
// pretty-expanded FIXME #23616
-pub fn increment(x: uint) -> uint {
+pub fn increment(x: usize) -> usize {
x + 1
}
}
pub fn main() {
- assert!(overly_complicated!(f, x, Option<uint>, { return Some(x); },
+ assert!(overly_complicated!(f, x, Option<usize>, { return Some(x); },
Some(8), Some(y), y) == 8)
}
struct A;
-macro_rules! make_thirteen_method {() => (fn thirteen(&self)->int {13})}
+macro_rules! make_thirteen_method {() => (fn thirteen(&self)->isize {13})}
impl A { make_thirteen_method!(); }
fn main() {
)
}
-fn f(c: Option<char>) -> uint {
+fn f(c: Option<char>) -> usize {
match c {
Some('x') => 1,
mypat!() => 2,
// pretty-expanded FIXME #23616
mod m {
- pub type t = int;
+ pub type t = isize;
}
macro_rules! foo {
macro_rules! myfn {
( $f:ident, ( $( $x:ident ),* ), $body:block ) => (
- fn $f( $( $x : int),* ) -> int $body
+ fn $f( $( $x : isize),* ) -> isize $body
)
}
pub mod glfw {
#[derive(Copy)]
- pub struct InputState(uint);
+ pub struct InputState(usize);
pub const RELEASE : InputState = InputState(0);
pub const PRESS : InputState = InputState(1);
fn issue_15393() {
#![allow(dead_code)]
struct Flags {
- bits: uint
+ bits: usize
}
const FOO: Flags = Flags { bits: 0x01 };
// n.b. This was only ever failing with optimization disabled.
// pretty-expanded FIXME #23616
-fn a() -> int { match return 1 { 2 => 3, _ => panic!() } }
+fn a() -> isize { match return 1 { 2 => 3, _ => panic!() } }
pub fn main() { a(); }
pub fn main() {
- let i: int =
- match Some::<int>(3) { None::<int> => { panic!() } Some::<int>(_) => { 5 } };
+ let i: isize =
+ match Some::<isize>(3) { None::<isize> => { panic!() } Some::<isize>(_) => { 5 } };
println!("{}", i);
}
// pretty-expanded FIXME #23616
enum E {
- Foo{f : int},
+ Foo{f : isize},
Bar
}
// pretty-expanded FIXME #23616
enum E {
- Foo{f : int},
+ Foo{f : isize},
Bar
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct Pair { a: Box<int>, b: Box<int> }
+struct Pair { a: Box<isize>, b: Box<isize> }
pub fn main() {
let mut x: Box<_> = box Pair {a: box 10, b: box 20};
// pretty-expanded FIXME #23616
enum Foo {
- B { b1: int, bb1: int},
+ B { b1: isize, bb1: isize},
}
macro_rules! match_inside_expansion {
// except according to those terms.
fn foo<T>(y: Option<T>) {
- let mut x: int;
- let mut rs: Vec<int> = Vec::new();
+ let mut x: isize;
+ let mut rs: Vec<isize> = Vec::new();
/* tests that x doesn't get put in the precondition for the
entire if expression */
return;
}
-pub fn main() { println!("hello"); foo::<int>(Some::<int>(5)); }
+pub fn main() { println!("hello"); foo::<isize>(Some::<isize>(5)); }
// pretty-expanded FIXME #23616
-struct X { x: int }
+struct X { x: isize }
pub fn main() {
let _x = match 0 {
// pretty-expanded FIXME #23616
-struct X { x: int }
+struct X { x: isize }
pub fn main() {
let _x = match 0 {
-fn altlit(f: int) -> int {
+fn altlit(f: isize) -> isize {
match f {
10 => { println!("case 10"); return 20; }
11 => { println!("case 11"); return 22; }
enum maybe<T> { nothing, just(T), }
-fn foo(x: maybe<int>) {
+fn foo(x: maybe<isize>) {
match x {
maybe::nothing => { println!("A"); }
maybe::just(_a) => { println!("B"); }
// pretty-expanded FIXME #23616
-fn altsimple(f: int) { match f { _x => () } }
+fn altsimple(f: isize) { match f { _x => () } }
pub fn main() { }
enum thing { a, b, c, }
-fn foo<F>(it: F) where F: FnOnce(int) { it(10); }
+fn foo<F>(it: F) where F: FnOnce(isize) { it(10); }
pub fn main() {
let mut x = true;
// pretty-expanded FIXME #23616
-const s: int = 1;
-const e: int = 42;
+const s: isize = 1;
+const e: isize = 42;
pub fn main() {
match 7 {
// pretty-expanded FIXME #23616
struct Rec {
- f: int
+ f: isize
}
fn destructure(x: &mut Rec) {
// pretty-expanded FIXME #23616
-fn destructure(x: Option<int>) -> int {
+fn destructure(x: Option<isize>) -> isize {
match x {
None => 0,
Some(ref v) => *v
#![deny(non_upper_case_globals)]
-pub const A : int = 97;
+pub const A : isize = 97;
fn f() {
let r = match (0,0) {
mod m {
#[allow(non_upper_case_globals)]
- pub const aha : int = 7;
+ pub const aha : isize = 7;
}
fn g() {
// pretty-expanded FIXME #23616
struct Foo{
- f : int,
+ f : isize,
}
pub fn main() {
// pretty-expanded FIXME #23616
enum color {
- rgb(int, int, int),
- rgba(int, int, int, int),
- hsl(int, int, int),
+ rgb(isize, isize, isize),
+ rgba(isize, isize, isize, isize),
+ hsl(isize, isize, isize),
}
-fn process(c: color) -> int {
- let mut x: int;
+fn process(c: color) -> isize {
+ let mut x: isize;
match c {
color::rgb(r, _, _) => { x = r; }
color::rgba(_, _, _, a) => { x = a; }
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn foo(x: Option<Box<int>>, b: bool) -> int {
+fn foo(x: Option<Box<isize>>, b: bool) -> isize {
match x {
None => { 1 }
Some(ref x) if b => { *x.clone() }
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
fn match_vecs<'a, T>(l1: &'a [T], l2: &'a [T]) -> &'static str {
match (l1, l2) {
fn main() {
assert_eq!(match_vecs(&[1, 2], &[2, 3]), "both non-empty");
assert_eq!(match_vecs(&[], &[1, 2, 3, 4]), "one empty");
- assert_eq!(match_vecs::<uint>(&[], &[]), "both empty");
+ assert_eq!(match_vecs::<usize>(&[], &[]), "both empty");
assert_eq!(match_vecs(&[1, 2, 3], &[]), "one empty");
assert_eq!(match_vecs_cons(&[1, 2], &[2, 3]), "both non-empty");
assert_eq!(match_vecs_cons(&[], &[1, 2, 3, 4]), "one empty");
- assert_eq!(match_vecs_cons::<uint>(&[], &[]), "both empty");
+ assert_eq!(match_vecs_cons::<usize>(&[], &[]), "both empty");
assert_eq!(match_vecs_cons(&[1, 2, 3], &[]), "one empty");
assert_eq!(match_vecs_snoc(&[1, 2], &[2, 3]), "both non-empty");
assert_eq!(match_vecs_snoc(&[], &[1, 2, 3, 4]), "one empty");
- assert_eq!(match_vecs_snoc::<uint>(&[], &[]), "both empty");
+ assert_eq!(match_vecs_snoc::<usize>(&[], &[]), "both empty");
assert_eq!(match_vecs_snoc(&[1, 2, 3], &[]), "one empty");
assert_eq!(match_nested_vecs_cons(None, Ok::<&[_], ()>(&[4_usize, 2_usize])),
"None, Ok(at least two elements)");
- assert_eq!(match_nested_vecs_cons::<uint>(None, Err(())), "None, Ok(less than one element)");
+ assert_eq!(match_nested_vecs_cons::<usize>(None, Err(())), "None, Ok(less than one element)");
assert_eq!(match_nested_vecs_cons::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])),
"Some(empty), Ok(empty)");
assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any");
assert_eq!(match_nested_vecs_snoc(None, Ok::<&[_], ()>(&[4_usize, 2_usize])),
"None, Ok(at least two elements)");
- assert_eq!(match_nested_vecs_snoc::<uint>(None, Err(())), "None, Ok(less than one element)");
+ assert_eq!(match_nested_vecs_snoc::<usize>(None, Err(())), "None, Ok(less than one element)");
assert_eq!(match_nested_vecs_snoc::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])),
"Some(empty), Ok(empty)");
assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any");
// except according to those terms.
trait Product {
- fn product(&self) -> int;
+ fn product(&self) -> isize;
}
struct Foo {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
impl Foo {
- pub fn sum(&self) -> int {
+ pub fn sum(&self) -> isize {
self.x + self.y
}
}
impl Product for Foo {
- fn product(&self) -> int {
+ fn product(&self) -> isize {
self.x * self.y
}
}
-fn Foo(x: int, y: int) -> Foo {
+fn Foo(x: isize, y: isize) -> Foo {
Foo { x: x, y: y }
}
}
#[int_frobable]
-impl frobable for int {
+impl frobable for isize {
#[frob_attr1]
fn frob(&self) {
#![frob_attr2]
impl<'a> MyWriter for &'a mut [u8] {
fn my_write(&mut self, buf: &[u8]) -> IoResult<()> {
- slice::bytes::copy_memory(*self, buf);
+ slice::bytes::copy_memory(buf, *self);
let write_len = buf.len();
unsafe {
fn finish(&self) -> u64 { 4 }
}
-impl Hash<SipHasher> for int {
+impl Hash<SipHasher> for isize {
fn hash(&self, h: &mut SipHasher) {}
}
fn make_string(&self) -> String;
}
-impl MakeString for int {
+impl MakeString for isize {
fn make_string(&self) -> String {
format!("{}", *self)
}
}
-impl MakeString for uint {
+impl MakeString for usize {
fn make_string(&self) -> String {
format!("{}", *self)
}
///////////////////////////////////////////////////////////////////////////
struct SomeStruct {
- field: int,
+ field: isize,
}
impl Foo for SomeStruct {
- type F = int;
+ type F = isize;
- fn get(&self) -> &int {
+ fn get(&self) -> &isize {
&self.field
}
}
///////////////////////////////////////////////////////////////////////////
struct SomeOtherStruct {
- field: uint,
+ field: usize,
}
impl Foo for SomeOtherStruct {
- type F = uint;
+ type F = usize;
- fn get(&self) -> &uint {
+ fn get(&self) -> &usize {
&self.field
}
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-static mut COUNT: uint = 1;
+static mut COUNT: usize = 1;
#[derive(Copy)]
struct Foo;
#![feature(box_syntax)]
trait Foo {
- fn foo(&self) -> int;
+ fn foo(&self) -> isize;
}
impl<T:Copy> Foo for Vec<T> {
- fn foo(&self) -> int {1}
+ fn foo(&self) -> isize {1}
}
impl<T> Foo for Vec<Box<T>> {
- fn foo(&self) -> int {2}
+ fn foo(&self) -> isize {2}
}
-fn call_foo_copy() -> int {
+fn call_foo_copy() -> isize {
let mut x = Vec::new();
let y = x.foo();
x.push(0_usize);
y
}
-fn call_foo_other() -> int {
+fn call_foo_other() -> isize {
let mut x: Vec<Box<_>> = Vec::new();
let y = x.foo();
x.push(box 0);
}
fn main() {
- let x: [int; 4] = [1,2,3,4];
- let xptr = x.as_slice() as *const [int];
+ let x: [isize; 4] = [1,2,3,4];
+ let xptr = x.as_slice() as *const [isize];
xptr.foo();
}
}
struct S2 {
- contents: int,
+ contents: isize,
}
-impl Trait<int> for S2 {
- fn new<U>(x: int, _: U) -> S2 {
+impl Trait<isize> for S2 {
+ fn new<U>(x: isize, _: U) -> S2 {
S2 {
contents: x,
}
}
pub fn main() {
- let _ = S::<int>::new::<f64>(1, 1.0);
- let _: S2 = Trait::<int>::new::<f64>(1, 1.0);
+ let _ = S::<isize>::new::<f64>(1, 1.0);
+ let _: S2 = Trait::<isize>::new::<f64>(1, 1.0);
}
// pretty-expanded FIXME #23616
-fn f() -> int {
+fn f() -> isize {
mod m {
- pub fn g() -> int { 720 }
+ pub fn g() -> isize { 720 }
}
m::g()
// pretty-expanded FIXME #23616
mod m {
- pub fn f() -> Vec<int> { Vec::new() }
+ pub fn f() -> Vec<isize> { Vec::new() }
}
pub fn main() { let _x = m::f(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn foo() -> int { 10 }
+pub fn foo() -> isize { 10 }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn foo() -> int { 10 }
+pub fn foo() -> isize { 10 }
// ignore-test Not a test. Used by other tests
-pub fn foo() -> int { 10 }
+pub fn foo() -> isize { 10 }
mod m {
pub struct S {
- pub x: int,
- pub y: int
+ pub x: isize,
+ pub y: isize
}
}
}
}
-fn transform(x: Option<int>) -> Option<String> {
+fn transform(x: Option<isize>) -> Option<String> {
x.bind(|n| Some(*n + 1) ).bind(|n| Some(n.to_string()) )
}
fn serialize<S:Serializer>(&self, s: S);
}
-impl Serializable for int {
+impl Serializable for isize {
fn serialize<S:Serializer>(&self, _s: S) { }
}
}
}
-impl Serializer for int {
+impl Serializer for isize {
}
pub fn main() {
#[derive(Clone)]
struct Triple {
- x: int,
- y: int,
- z: int,
+ x: isize,
+ y: isize,
+ z: isize,
}
-fn test(x: bool, foo: Box<Triple>) -> int {
+fn test(x: bool, foo: Box<Triple>) -> isize {
let bar = foo;
let mut y: Box<Triple>;
if x { y = bar; } else { y = box Triple{x: 4, y: 5, z: 6}; }
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct X { x: int, y: int, z: int }
+struct X { x: isize, y: isize, z: isize }
pub fn main() {
let x: Box<_> = box X{x: 1, y: 2, z: 3};
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct X { x: int, y: int, z: int }
+struct X { x: isize, y: isize, z: isize }
pub fn main() { let x: Box<_> = box X {x: 1, y: 2, z: 3}; let y = x; assert!((y.y == 2)); }
#[derive(Clone)]
struct Triple {
- x: int,
- y: int,
- z: int,
+ x: isize,
+ y: isize,
+ z: isize,
}
-fn test(x: bool, foo: Box<Triple>) -> int {
+fn test(x: bool, foo: Box<Triple>) -> isize {
let bar = foo;
let mut y: Box<Triple>;
if x { y = bar; } else { y = box Triple {x: 4, y: 5, z: 6}; }
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct Triple {a: int, b: int, c: int}
+struct Triple {a: isize, b: isize, c: isize}
fn test(foo: Box<Triple>) -> Box<Triple> {
let foo = foo;
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct Triple { a: int, b: int, c: int }
+struct Triple { a: isize, b: isize, c: isize }
fn test(foo: Box<Triple>) -> Box<Triple> {
let foo = foo;
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn test(foo: Box<Vec<int>> ) { assert!(((*foo)[0] == 10)); }
+fn test(foo: Box<Vec<isize>> ) { assert!(((*foo)[0] == 10)); }
pub fn main() {
let x = box vec!(10);
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn test(foo: Box<Vec<int>>) { assert!(((*foo)[0] == 10)); }
+fn test(foo: Box<Vec<isize>>) { assert!(((*foo)[0] == 10)); }
pub fn main() {
let x = box vec!(10);
// pretty-expanded FIXME #23616
-fn test(foo: int) { assert!((foo == 10)); }
+fn test(foo: isize) { assert!((foo == 10)); }
pub fn main() { let x = 10; test(x); }
pub fn main() {
- let y: int = 42;
- let mut x: int;
+ let y: isize = 42;
+ let mut x: isize;
x = y;
assert_eq!(x, 42);
}
#[derive(Copy)]
struct MyType {
- dummy: uint
+ dummy: usize
}
-impl MyTrait<uint> for MyType {
- fn get(&self) -> uint { self.dummy }
+impl MyTrait<usize> for MyType {
+ fn get(&self) -> usize { self.dummy }
}
impl MyTrait<u8> for MyType {
pub fn main() {
let value = MyType { dummy: 256 + 22 };
- test_eq::<uint, _>(value, value.dummy);
+ test_eq::<usize, _>(value, value.dummy);
test_eq::<u8, _>(value, value.dummy as u8);
}
#[derive(Copy)]
struct MyType {
- dummy: uint
+ dummy: usize
}
-impl MyTrait<uint> for MyType {
- fn get(&self) -> uint { self.dummy }
+impl MyTrait<usize> for MyType {
+ fn get(&self) -> usize { self.dummy }
}
fn test_eq<T,M>(m: M, v: T)
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f(mut y: Box<int>) {
+fn f(mut y: Box<isize>) {
*y = 5;
assert_eq!(*y, 5);
}
fn g() {
- let frob = |mut q: Box<int>| { *q = 2; assert!(*q == 2); };
+ let frob = |mut q: Box<isize>| { *q = 2; assert!(*q == 2); };
let w = box 37;
frob(w);
// pretty-expanded FIXME #23616
trait Foo {
- fn foo(&self, mut x: int) -> int {
+ fn foo(&self, mut x: isize) -> isize {
let val = x;
x = 37 * x;
val + x
assert_eq!(X.foo(2), 76);
enum Bar {
- Foo(int),
+ Foo(isize),
Baz(f32, u8)
}
}
}
- fn foo1((x, mut y): (f64, int), mut z: int) -> int {
+ fn foo1((x, mut y): (f64, isize), mut z: isize) -> isize {
y = 2 * 6;
- z = y + (x as int);
+ z = y + (x as isize);
y - z
}
struct A {
- x: int
+ x: isize
}
let A { x: mut x } = A { x: 10 };
assert_eq!(x, 10);
// pretty-expanded FIXME #23616
pub fn main() {
- let _x: &mut [int] = &mut [ 1, 2, 3 ];
+ let _x: &mut [isize] = &mut [ 1, 2, 3 ];
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn grow(v: &mut Vec<int> ) {
+fn grow(v: &mut Vec<isize> ) {
v.push(1);
}
pub fn main() {
- let mut v: Vec<int> = Vec::new();
+ let mut v: Vec<isize> = Vec::new();
grow(&mut v);
grow(&mut v);
grow(&mut v);
let len = v.len();
println!("{}", len);
- assert_eq!(len, 3 as uint);
+ assert_eq!(len, 3 as usize);
}
enum list { cons(Box<tree>, Box<list>), nil, }
-enum small_list { kons(int, Box<small_list>), neel, }
+enum small_list { kons(isize, Box<small_list>), neel, }
pub fn main() { }
pub enum Foo {
A,
- B(int),
- C { a: int },
+ B(isize),
+ C { a: isize },
}
impl Foo {
pub enum Bar {
D,
- E(int),
- F { a: int },
+ E(isize),
+ F { a: isize },
}
impl Bar {
mod m2 {
pub enum Foo {
A,
- B(int),
- C { a: int },
+ B(isize),
+ C { a: isize },
}
impl Foo {
enum Foo {
A,
- B(int),
- C { a: int },
+ B(isize),
+ C { a: isize },
}
fn _foo (f: Foo) {
#![feature(start)]
#[start]
-pub fn main(_: int, _: *const *const u8) -> int {
+pub fn main(_: isize, _: *const *const u8) -> isize {
println!("hello");
0
}
pub fn main() {
struct b {
- i: int,
+ i: isize,
}
impl b {
- fn do_stuff(&self) -> int { return 37; }
+ fn do_stuff(&self) -> isize { return 37; }
}
- fn b(i:int) -> b {
+ fn b(i:isize) -> b {
b {
i: i
}
}
- // fn b(x:int) -> int { panic!(); }
+ // fn b(x:isize) -> isize { panic!(); }
let z = b(42);
assert_eq!(z.i, 42);
// pretty-expanded FIXME #23616
-struct Foo { foo: bool, bar: Option<int>, baz: int }
+struct Foo { foo: bool, bar: Option<isize>, baz: isize }
pub fn main() {
match (Foo{foo: true, bar: Some(10), baz: 20}) {
pub struct X;
impl X {
- fn f(&self) -> int {
+ fn f(&self) -> isize {
#[inline(never)]
- fn inner() -> int {
+ fn inner() -> isize {
0
}
inner()
}
- fn g(&self) -> int {
+ fn g(&self) -> isize {
#[inline(never)]
- fn inner_2() -> int {
+ fn inner_2() -> isize {
1
}
inner_2()
}
- fn h(&self) -> int {
+ fn h(&self) -> isize {
#[inline(never)]
- fn inner() -> int {
+ fn inner() -> isize {
2
}
inner()
fn baz() -> ! { panic!(); }
fn foo() {
- match Some::<int>(5) {
- Some::<int>(_x) => {
+ match Some::<isize>(5) {
+ Some::<isize>(_x) => {
let mut bar;
- match None::<int> { None::<int> => { bar = 5; } _ => { baz(); } }
+ match None::<isize> { None::<isize> => { bar = 5; } _ => { baz(); } }
println!("{}", bar);
}
- None::<int> => { println!("hello"); }
+ None::<isize> => { println!("hello"); }
}
}
// a bug was causing this to complain about leaked memory on exit
-enum t { foo(int, uint), bar(int, Option<int>), }
+enum t { foo(isize, usize), bar(isize, Option<isize>), }
fn nested(o: t) {
match o {
- t::bar(_i, Some::<int>(_)) => { println!("wrong pattern matched"); panic!(); }
+ t::bar(_i, Some::<isize>(_)) => { println!("wrong pattern matched"); panic!(); }
_ => { println!("succeeded"); }
}
}
-pub fn main() { nested(t::bar(1, None::<int>)); }
+pub fn main() { nested(t::bar(1, None::<isize>)); }
--- /dev/null
+// Copyright 2015 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.
+
+// Test that using the `vec!` macro nested within itself works
+
+fn main() {
+ let nested = vec![vec![1u32, 2u32, 3u32]];
+ assert_eq!(nested[0][1], 2);
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Test that using the `vec!` macro nested within itself works
+// when the contents implement Drop
+
+struct D(u32);
+
+impl Drop for D {
+ fn drop(&mut self) { println!("Dropping {}", self.0); }
+}
+
+fn main() {
+ let nested = vec![vec![D(1u32), D(2u32), D(3u32)]];
+ assert_eq!(nested[0][1].0, 2);
+}
--- /dev/null
+// Copyright 2015 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.
+
+// Test that using the `vec!` macro nested within itself works when
+// the contents implement Drop and we hit a panic in the middle of
+// construction.
+
+
+use std::thread;
+use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
+
+static LOG: AtomicUsize = ATOMIC_USIZE_INIT;
+
+struct D(u8);
+
+impl Drop for D {
+ fn drop(&mut self) {
+ println!("Dropping {}", self.0);
+ let old = LOG.load(Ordering::SeqCst);
+ LOG.compare_and_swap(old, old << 4 | self.0 as usize, Ordering::SeqCst);
+ }
+}
+
+fn main() {
+ fn die() -> D { panic!("Oh no"); }
+ let g = thread::spawn(|| {
+ let _nested = vec![vec![D( 1), D( 2), D( 3), D( 4)],
+ vec![D( 5), D( 6), D( 7), D( 8)],
+ vec![D( 9), D(10), die(), D(12)],
+ vec![D(13), D(14), D(15), D(16)]];
+ });
+ assert!(g.join().is_err());
+
+ // When the panic occurs, we will be in the midst of constructing the
+ // second inner vector. Therefore, we drop the elements of the
+ // partially filled vector first, before we get around to dropping
+ // the elements of the filled vector.
+
+ // Issue 23222: The order in which the elements actually get
+ // dropped is a little funky: as noted above, we'll drop the 9+10
+ // first, but due to #23222, they get dropped in reverse
+ // order. Likewise, again due to #23222, we will drop the second
+ // filled vec before the first filled vec.
+ //
+ // If Issue 23222 is "fixed", then presumably the corrected
+ // expected order of events will be 0x__9_A__1_2_3_4__5_6_7_8;
+ // that is, we would still drop 9+10 first, since they belong to
+ // the more deeply nested expression when the panic occurs.
+
+ let expect = 0x__A_9__5_6_7_8__1_2_3_4;
+ let actual = LOG.load(Ordering::SeqCst);
+ assert!(actual == expect, "expect: 0x{:x} actual: 0x{:x}", expect, actual);
+}
pub fn main() {
assert_eq!(2, nested_item::foo::<()>());
- assert_eq!(2, nested_item::foo::<int>());
+ assert_eq!(2, nested_item::foo::<isize>());
}
use std::boxed::{Box, HEAP};
struct Structure {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
pub fn main() {
- let x: Box<int> = box(HEAP) 2;
- let y: Box<int> = box 2;
- let b: Box<int> = box()(1 + 2);
+ let x: Box<isize> = box(HEAP) 2;
+ let y: Box<isize> = box 2;
+ let b: Box<isize> = box()(1 + 2);
let c = box()(3 + 4);
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f(x: Box<int>) {
- let y: &int = &*x;
+fn f(x: Box<isize>) {
+ let y: &isize = &*x;
println!("{}", *x);
println!("{}", *y);
}
use std::fmt;
struct Thingy {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
impl fmt::Debug for Thingy {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-static FOO: int = 3;
+static FOO: isize = 3;
pub fn main() {
println!("{}", FOO);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-static FOO: [int; 3] = [1, 2, 3];
+static FOO: [isize; 3] = [1, 2, 3];
pub fn main() {
println!("{} {} {}", FOO[0], FOO[1], FOO[2]);
// pretty-expanded FIXME #23616
fn main() {
- let _a: *const int = 3 as *const int;
- let _a: *mut int = 3 as *mut int;
+ let _a: *const isize = 3 as *const isize;
+ let _a: *mut isize = 3 as *mut isize;
}
// pretty-expanded FIXME #23616
-fn f<F>(i: int, f: F) -> int where F: FnOnce(int) -> int { f(i) }
+fn f<F>(i: isize, f: F) -> isize where F: FnOnce(isize) -> isize { f(i) }
fn g<G>(_g: G) where G: FnOnce() { }
use std::cell::Cell;
-struct Foo<'a>(&'a Cell<int>);
+struct Foo<'a>(&'a Cell<isize>);
#[unsafe_destructor]
impl<'a> Drop for Foo<'a> {
// except according to those terms.
#[derive(PartialEq, Debug)]
-struct Foo(uint);
+struct Foo(usize);
fn foo() -> Foo {
Foo(42)
#[derive(Copy)]
struct Mytype {
- compute: fn(mytype) -> int,
- val: int,
+ compute: fn(mytype) -> isize,
+ val: isize,
}
-fn compute(i: mytype) -> int {
+fn compute(i: mytype) -> isize {
let mytype(m) = i;
return m.val + 20;
}
}
#[start]
-pub fn main(_: int, _: **u8, _: *u8) -> int {
+pub fn main(_: isize, _: **u8, _: *u8) -> isize {
no_std_crate::foo();
0
}
// pretty-expanded FIXME #23616
struct X {
- repr: int
+ repr: isize
}
fn apply<T, F>(x: T, f: F) where F: FnOnce(T) {
f(x);
}
-fn check_int(x: int) {
+fn check_int(x: isize) {
assert_eq!(x, 22);
}
use std::mem;
#[inline(never)]
-extern "C" fn foo<'a>(x: &'a int) -> Option<&'a int> { Some(x) }
+extern "C" fn foo<'a>(x: &'a isize) -> Option<&'a isize> { Some(x) }
-static FOO: int = 0xDEADBEE;
+static FOO: isize = 0xDEADBEE;
pub fn main() {
unsafe {
- let f: for<'a> extern "C" fn(&'a int) -> &'a int = mem::transmute(foo);
+ let f: for<'a> extern "C" fn(&'a isize) -> &'a isize = mem::transmute(foo);
assert_eq!(*f(&FOO), FOO);
}
}
// trying to get assert failure messages that at least identify which case
// failed.
-enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8; 0]) }
+enum E<T> { Thing(isize, T), Nothing((), ((), ()), [i8; 0]) }
impl<T> E<T> {
fn is_none(&self) -> bool {
match *self {
E::Nothing(..) => true
}
}
- fn get_ref(&self) -> (int, &T) {
+ fn get_ref(&self) -> (isize, &T) {
match *self {
E::Nothing(..) => panic!("E::get_ref(Nothing::<{}>)", stringify!(T)),
E::Thing(x, ref y) => (x, y)
}
pub fn main() {
- check_type!(&17, &int);
- check_type!(box 18, Box<int>);
+ check_type!(&17, &isize);
+ check_type!(box 18, Box<isize>);
check_type!("foo".to_string(), String);
- check_type!(vec!(20, 22), Vec<int> );
- let mint: uint = unsafe { mem::transmute(main) };
+ check_type!(vec!(20, 22), Vec<isize> );
+ let mint: usize = unsafe { mem::transmute(main) };
check_type!(main, fn(), |pthing| {
assert!(mint == unsafe { mem::transmute(*pthing) })
});
use std::mem;
-enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8; 0]) }
-struct S<T>(int, T);
+enum E<T> { Thing(isize, T), Nothing((), ((), ()), [i8; 0]) }
+struct S<T>(isize, T);
// These are macros so we get useful assert messages.
}
pub fn main() {
- check_type!(&'static int);
- check_type!(Box<int>);
+ check_type!(&'static isize);
+ check_type!(Box<isize>);
check_type!(extern fn());
}
enum blah { a, b, }
-fn or_alt(q: blah) -> int {
+fn or_alt(q: blah) -> isize {
match q { blah::a | blah::b => { 42 } }
}
use std::any::Any;
trait Wrap {
- fn get(&self) -> int;
+ fn get(&self) -> isize;
fn wrap(self: Box<Self>) -> Box<Any+'static>;
}
-impl Wrap for int {
- fn get(&self) -> int {
+impl Wrap for isize {
+ fn get(&self) -> isize {
*self
}
- fn wrap(self: Box<i
nt>) -> Box<Any+'static> {
+ fn wrap(self: Box<i
size>) -> Box<Any+'static> {
self as Box<Any+'static>
}
}
-fn is<T:'static>(x: &Any) -> bool {
+fn is<T:Any>(x: &Any) -> bool {
x.is::<T>()
}
// pretty-expanded FIXME #23616
trait Foo {
- fn foo(&self) -> uint;
- fn bar(&mut self) -> uint;
+ fn foo(&self) -> usize;
+ fn bar(&mut self) -> usize;
}
-impl Foo for uint {
- fn foo(&self) -> uint {
+impl Foo for usize {
+ fn foo(&self) -> usize {
*self
}
- fn bar(&mut self) -> uint {
+ fn bar(&mut self) -> usize {
*self += 1;
*self
}
do_it_imm(obj, y);
}
-fn do_it_imm(obj: &Foo, v: uint) {
+fn do_it_imm(obj: &Foo, v: usize) {
let y = obj.foo();
assert_eq!(v, y);
}
pub fn main() {
- let mut x: uint = 22;
+ let mut x: usize = 22;
let obj = &mut x as &mut Foo;
do_it_mut(obj);
do_it_imm(obj, 23);
trait FooTrait {
- fn foo(&self) -> uint;
+ fn foo(&self) -> usize;
}
struct BarStruct {
- x: uint
+ x: usize
}
impl FooTrait for BarStruct {
- fn foo(&self) -> uint {
+ fn foo(&self) -> usize {
self.x
}
}
#![feature(box_syntax)]
trait FooTrait {
- fn foo(self: Box<Self>) -> uint;
+ fn foo(self: Box<Self>) -> usize;
}
struct BarStruct {
- x: uint
+ x: usize
}
impl FooTrait for BarStruct {
- fn foo(self: Box<BarStruct>) -> uint {
+ fn foo(self: Box<BarStruct>) -> usize {
self.x
}
}
pub fn main() {
- let mut x: int = 1;
+ let mut x: isize = 1;
x *= 2;
println!("{}", x);
assert_eq!(x, 2);
#[derive(Debug,PartialEq,Eq)]
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
impl ops::Add for Point {
}
}
-impl ops::Add<int> for Point {
+impl ops::Add<isize> for Point {
type Output = Point;
- fn add(self, other: int) -> Point {
+ fn add(self, other: isize) -> Point {
Point {x: self.x + other,
y: self.y + other}
}
#[derive(Copy, Debug)]
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
impl ops::Add for Point {
}
impl ops::Index<bool> for Point {
- type Output = int;
+ type Output = isize;
- fn index(&self, x: bool) -> &int {
+ fn index(&self, x: bool) -> &isize {
if x {
&self.x
} else {
result(p[true]);
}
-fn result(i: int) { }
+fn result(i: isize) { }
use std::cell::Cell;
struct dtor<'a> {
- x: &'a Cell<int>,
+ x: &'a Cell<isize>,
}
#[unsafe_destructor]
// pretty-expanded FIXME #23616
-enum blah { a(int, int, uint), b(int, int), c, }
+enum blah { a(isize, isize, usize), b(isize, isize), c, }
-fn or_alt(q: blah) -> int {
+fn or_alt(q: blah) -> isize {
match q { blah::a(x, y, _) | blah::b(x, y) => { return x + y; } blah::c => { return 0; } }
}
// pretty-expanded FIXME #23616
-static mut ORDER: [uint; 3] = [0, 0, 0];
-static mut INDEX: uint = 0;
+static mut ORDER: [usize; 3] = [0, 0, 0];
+static mut INDEX: usize = 0;
struct A;
impl Drop for A {
#[derive(Copy)]
pub struct Foo {
- f1: int,
- _f2: int,
+ f1: isize,
+ _f2: isize,
}
#[inline(never)]
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct A { a: int, b: int }
-struct Abox { a: Box<int>, b: Box<int> }
+struct A { a: isize, b: isize }
+struct Abox { a: Box<isize>, b: Box<isize> }
-fn ret_int_i() -> int { 10 }
+fn ret_int_i() -> isize { 10 }
-fn ret_ext_i() -> Box<int> { box 10 }
+fn ret_ext_i() -> Box<isize> { box 10 }
fn ret_int_rec() -> A { A {a: 10, b: 10} }
fn ret_ext_ext_mem() -> Box<Abox> { box Abox{a: box 10, b: box 10} }
pub fn main() {
- let mut int_i: int;
- let mut ext_i: Box<int>;
+ let mut int_i: isize;
+ let mut ext_i: Box<isize>;
let mut int_rec: A;
let mut ext_rec: Box<A>;
let mut ext_mem: Abox;
// Regression test for issue #152.
pub fn main() {
- let mut b: uint = 1_usize;
+ let mut b: usize = 1_usize;
while b < std::mem::size_of::<usize>() {
0_usize << b;
b <<= 1_usize;
#[derive(PartialEq)]
struct DerefCounter<T> {
- count_imm: Cell<uint>,
- count_mut: uint,
+ count_imm: Cell<usize>,
+ count_mut: usize,
value: T
}
}
}
- fn counts(&self) -> (uint, uint) {
+ fn counts(&self) -> (usize, usize) {
(self.count_imm.get(), self.count_mut)
}
}
#[derive(PartialEq, Debug)]
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
impl Point {
- fn get(&self) -> (int, int) {
+ fn get(&self) -> (isize, isize) {
(self.x, self.y)
}
}
}
}
-struct Foo {x: int}
+struct Foo {x: isize}
impl Foo {
- fn foo(&self) -> int {self.x}
+ fn foo(&self) -> isize {self.x}
}
pub fn main() {
#[derive(PartialEq, Debug)]
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
pub fn main() {
// pretty-expanded FIXME #23616
-fn foo(f: &mut FnMut(int) -> int) -> int {
+fn foo(f: &mut FnMut(isize) -> isize) -> isize {
f(22)
}
// pretty-expanded FIXME #23616
-fn foo(f: &mut FnMut(int, int) -> int) -> int {
+fn foo(f: &mut FnMut(isize, isize) -> isize) -> isize {
f(1, 2)
}
// pretty-expanded FIXME #23616
-fn foo(f: &mut FnMut() -> int) -> int {
+fn foo(f: &mut FnMut() -> isize) -> isize {
f()
}
#![feature(unboxed_closures, core)]
-use std::ops::{FnMut};
+use std::ops::FnMut;
struct S {
x: i32,
use std::vec::Vec;
struct DerefCounter<T> {
- count_imm: Cell<uint>,
- count_mut: uint,
+ count_imm: Cell<usize>,
+ count_mut: usize,
value: T
}
}
}
- fn counts(&self) -> (uint, uint) {
+ fn counts(&self) -> (usize, usize) {
(self.count_imm.get(), self.count_mut)
}
}
#[derive(PartialEq, Debug)]
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
pub fn main() {
use std::ops::{Index, IndexMut};
struct Foo {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
-impl Index<int> for Foo {
- type Output = int;
+impl Index<isize> for Foo {
+ type Output = isize;
- fn index(&self, z: int) -> &int {
+ fn index(&self, z: isize) -> &isize {
if z == 0 {
&self.x
} else {
}
}
-impl IndexMut<int> for Foo {
- fn index_mut(&mut self, z: int) -> &mut int {
+impl IndexMut<isize> for Foo {
+ fn index_mut(&mut self, z: isize) -> &mut isize {
if z == 0 {
&mut self.x
} else {
}
trait Int {
- fn get(self) -> int;
- fn get_from_ref(&self) -> int;
+ fn get(self) -> isize;
+ fn get_from_ref(&self) -> isize;
fn inc(&mut self);
}
-impl Int for int {
- fn get(self) -> int { self }
- fn get_from_ref(&self) -> int { *self }
+impl Int for isize {
+ fn get(self) -> isize { self }
+ fn get_from_ref(&self) -> isize { *self }
fn inc(&mut self) { *self += 1; }
}
use std::ops::Index;
struct Foo {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
struct Bar {
foo: Foo
}
-impl Index<int> for Foo {
- type Output = int;
+impl Index<isize> for Foo {
+ type Output = isize;
- fn index(&self, z: int) -> &int {
+ fn index(&self, z: isize) -> &isize {
if z == 0 {
&self.x
} else {
}
trait Int {
- fn get(self) -> int;
- fn get_from_ref(&self) -> int;
+ fn get(self) -> isize;
+ fn get_from_ref(&self) -> isize;
fn inc(&mut self);
}
-impl Int for int {
- fn get(self) -> int { self }
- fn get_from_ref(&self) -> int { *self }
+impl Int for isize {
+ fn get(self) -> isize { self }
+ fn get_from_ref(&self) -> isize { *self }
fn inc(&mut self) { *self += 1; }
}
use std::ops::{Index, IndexMut};
struct Foo {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
-impl Index<int> for Foo {
- type Output = int;
+impl Index<isize> for Foo {
+ type Output = isize;
- fn index(&self, z: int) -> &int {
+ fn index(&self, z: isize) -> &isize {
if z == 0 {
&self.x
} else {
}
}
-impl IndexMut<int> for Foo {
- fn index_mut(&mut self, z: int) -> &mut int {
+impl IndexMut<isize> for Foo {
+ fn index_mut(&mut self, z: isize) -> &mut isize {
if z == 0 {
&mut self.x
} else {
}
trait Int {
- fn get(self) -> int;
- fn get_from_ref(&self) -> int;
+ fn get(self) -> isize;
+ fn get_from_ref(&self) -> isize;
fn inc(&mut self);
}
-impl Int for int {
- fn get(self) -> int { self }
- fn get_from_ref(&self) -> int { *self }
+impl Int for isize {
+ fn get(self) -> isize { self }
+ fn get_from_ref(&self) -> isize { *self }
fn inc(&mut self) { *self += 1; }
}
#[repr(packed)]
struct Foo {
bar: u8,
- baz: uint
+ baz: usize
}
pub fn main() {
#[repr(packed)]
struct Foo {
bar: u8,
- baz: uint
+ baz: usize
}
pub fn main() {
}
struct B {
- foo: int,
+ foo: isize,
}
impl Drop for A {
fn foo1<T>(_: &(A<T> + Send)) {}
fn foo2<T>(_: Box<A<T> + Send + Sync>) {}
-fn foo3<T>(_: Box<B<int, uint> + 'static>) {}
+fn foo3<T>(_: Box<B<isize, usize> + 'static>) {}
fn foo4<'a, T>(_: Box<C<'a, T> + 'static + Send>) {}
fn foo5<'a, T>(_: Box<foo::D<'a, T> + 'static + Send>) {}
// pretty-expanded FIXME #23616
mod foo {
- pub fn bar(_offset: uint) { }
+ pub fn bar(_offset: usize) { }
}
pub fn main() { foo::bar(0); }
// pretty-expanded FIXME #23616
-fn foo(src: uint) {
+fn foo(src: usize) {
match Some(src) {
Some(src_id) => {
// except according to those terms.
struct Foo {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
pub fn main() {
- let f = |(x, _): (int, int)| println!("{}", x + 1);
+ let f = |(x, _): (isize, isize)| println!("{}", x + 1);
let g = |Foo { x: x, y: _y }: Foo| println!("{}", x + 1);
f((2, 3));
g(Foo { x: 1, y: 2 });
// pretty-expanded FIXME #23616
-fn bad(_a: int) -> int { return 37; } //~ ERROR Non-boolean return type
+fn bad(_a: isize) -> isize { return 37; } //~ ERROR Non-boolean return type
pub fn main() { }
// note: halfway done porting to modern rust
use std::comm;
-fn starve_main(alive: Receiver<int>) {
+fn starve_main(alive: Receiver<isize>) {
println!("signalling main");
alive.recv();
println!("starving main");
- let mut i: int = 0;
+ let mut i: isize = 0;
loop { i += 1; }
}
spawn(move|| {
starve_main(port);
});
- let mut i: int = 0;
+ let mut i: isize = 0;
println!("main waiting for alive signal");
chan.send(i);
println!("main got alive signal");
// pretty-expanded FIXME #23616
-extern crate "priv-impl-prim-ty" as bar;
+extern crate priv_impl_prim_ty as bar;
pub fn main() {
bar::frob(1);
// pretty-expanded FIXME #23616
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
}
impl cat {
- pub fn meow_count(&mut self) -> uint { self.meows }
+ pub fn meow_count(&mut self) -> usize { self.meows }
}
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
// pretty-expanded FIXME #23616
struct cat {
- meows : uint,
+ meows : usize,
- how_hungry : int,
+ how_hungry : isize,
}
impl cat {
fn nap(&mut self) { for _ in 1_usize..10_usize { } }
}
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : usize, in_y : isize) -> cat {
cat {
meows: in_x,
how_hungry: in_y
pub fn main() {
// &mut -> &
- let x: &mut int = &mut 42;
- let x: &int = x;
+ let x: &mut isize = &mut 42;
+ let x: &isize = x;
- let x: &int = &mut 42;
+ let x: &isize = &mut 42;
// & -> *const
- let x: &int = &42;
- let x: *const int = x;
+ let x: &isize = &42;
+ let x: *const isize = x;
- let x: *const int = &42;
+ let x: *const isize = &42;
// &mut -> *const
- let x: &mut int = &mut 42;
- let x: *const int = x;
+ let x: &mut isize = &mut 42;
+ let x: *const isize = x;
- let x: *const int = &mut 42;
+ let x: *const isize = &mut 42;
// *mut -> *const
- let x: *mut int = &mut 42;
- let x: *const int = x;
+ let x: *mut isize = &mut 42;
+ let x: *const isize = x;
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn sums_to(v: Vec<int> , sum: int) -> bool {
+fn sums_to(v: Vec<isize> , sum: isize) -> bool {
let mut i = 0;
let mut sum0 = 0;
while i < v.len() {
return sum0 == sum;
}
-fn sums_to_using_uniq(v: Vec<int> , sum: int) -> bool {
+fn sums_to_using_uniq(v: Vec<isize> , sum: isize) -> bool {
let mut i = 0;
let mut sum0: Box<_> = box 0;
while i < v.len() {
return *sum0 == sum;
}
-fn sums_to_using_rec(v: Vec<int> , sum: int) -> bool {
+fn sums_to_using_rec(v: Vec<isize> , sum: isize) -> bool {
let mut i = 0;
let mut sum0 = F {f: 0};
while i < v.len() {
struct F<T> { f: T }
-fn sums_to_using_uniq_rec(v: Vec<int> , sum: int) -> bool {
+fn sums_to_using_uniq_rec(v: Vec<isize> , sum: isize) -> bool {
let mut i = 0;
let mut sum0 = F::<Box<_>> {f: box 0};
while i < v.len() {
// pretty-expanded FIXME #23616
-fn foo() -> int { 42 }
+fn foo() -> isize { 42 }
// Test that range syntax works in return statements
fn return_range_to() -> ::std::ops::RangeTo<i32> { return ..1; }
// pretty-expanded FIXME #23616
struct Foo {
- foo: uint,
+ foo: usize,
}
impl Foo {
- fn bar(&self) -> uint { 5 }
+ fn bar(&self) -> usize { 5 }
}
fn main() {
#![feature(box_syntax)]
trait get {
- fn get(self) -> int;
+ fn get(self) -> isize;
}
// Note: impl on a slice; we're checking that the pointers below
-// correctly get borrowed to `&`. (similar to impling for `int`, with
+// correctly get borrowed to `&`. (similar to impling for `isize`, with
// `&self` instead of `self`.)
-impl<'a> get for &'a int {
- fn get(self) -> int {
+impl<'a> get for &'a isize {
+ fn get(self) -> isize {
return *self;
}
}
trait sum {
- fn sum_(self) -> int;
+ fn sum_(self) -> isize;
}
// Note: impl on a slice
-impl<'a> sum for &'a [int] {
- fn sum_(self) -> int {
+impl<'a> sum for &'a [isize] {
+ fn sum_(self) -> isize {
self.iter().fold(0, |a, &b| a + b)
}
}
-fn call_sum(x: &[int]) -> int { x.sum_() }
+fn call_sum(x: &[isize]) -> isize { x.sum_() }
pub fn main() {
let x = vec!(1, 2, 3);
// pretty-expanded FIXME #23616
-struct Point {x: int, y: int, z: int}
+struct Point {x: isize, y: isize, z: isize}
fn f(p: Point) { assert!((p.z == 12)); }
}
unsafe fn test_triangle() -> bool {
- static COUNT : uint = 16;
+ static COUNT : usize = 16;
let mut ascend = repeat(ptr::null_mut()).take(COUNT).collect::<Vec<_>>();
let ascend = &mut *ascend;
- static ALIGN : uint = 1;
+ static ALIGN : usize = 1;
// Checks that `ascend` forms triangle of ascending size formed
// from pairs of rows (where each pair of rows is equally sized),
for i in 0..COUNT / 2 {
let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
for j in 0..size {
- assert_eq!(*p0.offset(j as int), i as u8);
- assert_eq!(*p1.offset(j as int), i as u8);
+ assert_eq!(*p0.offset(j as isize), i as u8);
+ assert_eq!(*p1.offset(j as isize), i as u8);
}
}
}
static PRINT : bool = false;
- unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
+ unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
if PRINT { println!("allocate(size={} align={})", size, align); }
let ret = heap::allocate(size, align);
if ret.is_null() { alloc::oom() }
if PRINT { println!("allocate(size={} align={}) ret: 0x{:010x}",
- size, align, ret as uint);
+ size, align, ret as usize);
}
ret
}
- unsafe fn deallocate(ptr: *mut u8, size: uint, align: uint) {
+ unsafe fn deallocate(ptr: *mut u8, size: usize, align: usize) {
if PRINT { println!("deallocate(ptr=0x{:010x} size={} align={})",
- ptr as uint, size, align);
+ ptr as usize, size, align);
}
heap::deallocate(ptr, size, align);
}
- unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint) -> *mut u8 {
+ unsafe fn reallocate(ptr: *mut u8, old_size: usize, size: usize, align: usize) -> *mut u8 {
if PRINT {
println!("reallocate(ptr=0x{:010x} old_size={} size={} align={})",
- ptr as uint, old_size, size, align);
+ ptr as usize, old_size, size, align);
}
let ret = heap::reallocate(ptr, old_size, size, align);
if PRINT {
println!("reallocate(ptr=0x{:010x} old_size={} size={} align={}) \
ret: 0x{:010x}",
- ptr as uint, old_size, size, align, ret as uint);
+ ptr as usize, old_size, size, align, ret as usize);
}
ret
}
- fn idx_to_size(i: uint) -> uint { (i+1) * 10 }
+ fn idx_to_size(i: usize) -> usize { (i+1) * 10 }
// Allocate pairs of rows that form a triangle shape. (Hope is
// that at least two rows will be allocated near each other, so
for i in 0..COUNT / 2 {
let (p0, p1, size) = (ascend[2*i], ascend[2*i+1], idx_to_size(i));
for j in 0..size {
- *p0.offset(j as int) = i as u8;
- *p1.offset(j as int) = i as u8;
+ *p0.offset(j as isize) = i as u8;
+ *p1.offset(j as isize) = i as u8;
}
}
mod rusti {
extern "rust-intrinsic" {
- pub fn pref_align_of<T>() -> uint;
- pub fn min_align_of<T>() -> uint;
+ pub fn pref_align_of<T>() -> usize;
+ pub fn min_align_of<T>() -> usize;
}
}
#[cfg(any(target_arch = "x86", target_arch = "arm", target_arch = "aarch64"))]
mod m {
- pub fn align() -> uint { 4 }
- pub fn size() -> uint { 8 }
+ pub fn align() -> usize { 4 }
+ pub fn size() -> usize { 8 }
}
#[cfg(target_arch = "x86_64")]
mod m {
- pub fn align() -> uint { 4 }
- pub fn size() -> uint { 8 }
+ pub fn align() -> usize { 4 }
+ pub fn size() -> usize { 8 }
}
pub fn main() {
mod rusti {
extern "rust-intrinsic" {
- pub fn pref_align_of<T>() -> uint;
- pub fn min_align_of<T>() -> uint;
+ pub fn pref_align_of<T>() -> usize;
+ pub fn min_align_of<T>() -> usize;
}
}
mod m {
#[cfg(target_arch = "x86")]
pub mod m {
- pub fn align() -> uint { 4 }
- pub fn size() -> uint { 12 }
+ pub fn align() -> usize { 4 }
+ pub fn size() -> usize { 12 }
}
#[cfg(any(target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64"))]
pub mod m {
- pub fn align() -> uint { 8 }
- pub fn size() -> uint { 16 }
+ pub fn align() -> usize { 8 }
+ pub fn size() -> usize { 16 }
}
}
mod m {
#[cfg(target_arch = "x86_64")]
pub mod m {
- pub fn align() -> uint { 8 }
- pub fn size() -> uint { 16 }
+ pub fn align() -> usize { 8 }
+ pub fn size() -> usize { 16 }
}
}
mod m {
#[cfg(target_arch = "x86")]
pub mod m {
- pub fn align() -> uint { 8 }
- pub fn size() -> uint { 16 }
+ pub fn align() -> usize { 8 }
+ pub fn size() -> usize { 16 }
}
#[cfg(target_arch = "x86_64")]
pub mod m {
- pub fn align() -> uint { 8 }
- pub fn size() -> uint { 16 }
+ pub fn align() -> usize { 8 }
+ pub fn size() -> usize { 16 }
}
}
mod m {
#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
pub mod m {
- pub fn align() -> uint { 8 }
- pub fn size() -> uint { 16 }
+ pub fn align() -> usize { 8 }
+ pub fn size() -> usize { 16 }
}
}
// pretty-expanded FIXME #23616
-struct Point {x: int, y: int}
+struct Point {x: isize, y: isize}
pub fn main() {
let origin: Point = Point {x: 0, y: 0};
// pretty-expanded FIXME #23616
#[derive(Copy)]
-struct Point {x: int, y: int}
+struct Point {x: isize, y: isize}
type rect = (Point, Point);
fn fst(r: rect) -> Point { let (fst, _) = r; return fst; }
fn snd(r: rect) -> Point { let (_, snd) = r; return snd; }
-fn f(r: rect, x1: int, y1: int, x2: int, y2: int) {
+fn f(r: rect, x1: isize, y1: isize, x2: isize, y2: isize) {
assert_eq!(fst(r).x, x1);
assert_eq!(fst(r).y, y1);
assert_eq!(snd(r).x, x2);
assert_eq!(snd(r).x, 11);
assert_eq!(snd(r).y, 22);
let r2 = r;
- let x: int = fst(r2).x;
+ let x: isize = fst(r2).x;
assert_eq!(x, 10);
f(r, 10, 20, 11, 22);
f(r2, 10, 20, 11, 22);
// pretty-expanded FIXME #23616
#[derive(Copy)]
-struct Rect {x: int, y: int, w: int, h: int}
+struct Rect {x: isize, y: isize, w: isize, h: isize}
-fn f(r: Rect, x: int, y: int, w: int, h: int) {
+fn f(r: Rect, x: isize, y: isize, w: isize, h: isize) {
assert_eq!(r.x, x);
assert_eq!(r.y, y);
assert_eq!(r.w, w);
assert_eq!(r.w, 100);
assert_eq!(r.h, 200);
let r2: Rect = r;
- let x: int = r2.x;
+ let x: isize = r2.x;
assert_eq!(x, 10);
f(r, 10, 20, 100, 200);
f(r2, 10, 20, 100, 200);
// pretty-expanded FIXME #23616
-enum t1 { a(int), b(uint), }
-struct T2 {x: t1, y: int}
-enum t3 { c(T2, uint), }
+enum t1 { a(isize), b(usize), }
+struct T2 {x: t1, y: isize}
+enum t3 { c(T2, usize), }
-fn m(input: t3) -> int {
+fn m(input: t3) -> isize {
match input {
t3::c(T2 {x: t1::a(m), ..}, _) => { return m; }
- t3::c(T2 {x: t1::b(m), y: y}, z) => { return ((m + z) as int) + y; }
+ t3::c(T2 {x: t1::b(m), y: y}, z) => { return ((m + z) as isize) + y; }
}
}
// pretty-expanded FIXME #23616
-extern crate "reexport-should-still-link" as foo;
+extern crate reexport_should_still_link as foo;
pub fn main() {
foo::bar();
use reexported_static_methods::Bort;
pub fn main() {
- assert_eq!(42, Foo::foo());
- assert_eq!(84, Baz::bar());
+ assert_eq!(42_isize, Foo::foo());
+ assert_eq!(84_isize, Baz::bar());
assert!(Boz::boz(1));
assert_eq!("bort()".to_string(), Bort::bort());
}
// pretty-expanded FIXME #23616
struct Point {
- x: int,
- y: int
+ x: isize,
+ y: isize
}
struct Character {
pos: Box<Point>,
}
-fn get_x(x: &Character) -> &int {
+fn get_x(x: &Character) -> &isize {
// interesting case because the scope of this
// borrow of the unique pointer is in fact
// larger than the fn itself
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn f(x: &int) -> &int {
+fn f(x: &isize) -> &isize {
return &*x;
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn foo(x: &uint) -> uint {
+fn foo(x: &usize) -> usize {
*x
}
// pretty-expanded FIXME #23616
-fn foo(x: &[int]) -> int {
+fn foo(x: &[isize]) -> isize {
x[0]
}
// pretty-expanded FIXME #23616
-fn foo(x: &[int]) -> int {
+fn foo(x: &[isize]) -> isize {
x[0]
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn foo(x: &uint) -> uint {
+fn foo(x: &usize) -> usize {
*x
}
fn produce_static<T>() -> &'static T { panic!(); }
-fn foo<T>(_x: &T) -> &uint { produce_static() }
+fn foo<T>(_x: &T) -> &usize { produce_static() }
pub fn main() {
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-trait SomeTrait { fn get(&self) -> int; }
+trait SomeTrait { fn get(&self) -> isize; }
-impl<'a> SomeTrait for &'a int {
- fn get(&self) -> int {
+impl<'a> SomeTrait for &'a isize {
+ fn get(&self) -> isize {
**self
}
}
}
fn main() {
- let i: int = 22;
+ let i: isize = 22;
let obj = make_object(&i);
assert_eq!(22, obj.get());
}
// pretty-expanded FIXME #23616
enum ast<'a> {
- num(uint),
+ num(usize),
add(&'a ast<'a>, &'a ast<'a>)
}
// pretty-expanded FIXME #23616
enum ast<'a> {
- num(uint),
+ num(usize),
add(&'a ast<'a>, &'a ast<'a>)
}
}
struct B {
- v1: int,
- v2: [int; 3],
- v3: Vec<int> ,
+ v1: isize,
+ v2: [isize; 3],
+ v3: Vec<isize> ,
v4: C,
v5: Box<C>,
v6: Option<C>
#[derive(Copy)]
struct C {
- f: int
+ f: isize
}
-fn get_v1(a: &A) -> &int {
+fn get_v1(a: &A) -> &isize {
// Region inferencer must deduce that &v < L2 < L1
let foo = &a.value; // L1
&foo.v1 // L2
}
-fn get_v2(a: &A, i: uint) -> &int {
+fn get_v2(a: &A, i: usize) -> &isize {
let foo = &a.value;
&foo.v2[i]
}
-fn get_v3(a: &A, i: uint) -> &int {
+fn get_v3(a: &A, i: usize) -> &isize {
let foo = &a.value;
&foo.v3[i]
}
-fn get_v4(a: &A, _i: uint) -> &int {
+fn get_v4(a: &A, _i: usize) -> &isize {
let foo = &a.value;
&foo.v4.f
}
-fn get_v5(a: &A, _i: uint) -> &int {
+fn get_v5(a: &A, _i: usize) -> &isize {
let foo = &a.value;
&foo.v5.f
}
-fn get_v6_a(a: &A, _i: uint) -> &int {
+fn get_v6_a(a: &A, _i: usize) -> &isize {
match a.value.v6 {
Some(ref v) => &v.f,
None => panic!()
}
}
-fn get_v6_b(a: &A, _i: uint) -> &int {
+fn get_v6_b(a: &A, _i: usize) -> &isize {
match *a {
A { value: B { v6: Some(ref v), .. } } => &v.f,
_ => panic!()
}
}
-fn get_v6_c(a: &A, _i: uint) -> &int {
+fn get_v6_c(a: &A, _i: usize) -> &isize {
match a {
&A { value: B { v6: Some(ref v), .. } } => &v.f,
_ => panic!()
}
}
-fn get_v5_ref(a: &A, _i: uint) -> &int {
+fn get_v5_ref(a: &A, _i: usize) -> &isize {
match &a.value {
&B {v5: box C {f: ref v}, ..} => v
}
// pretty-expanded FIXME #23616
-fn subslice1<'r>(v: &'r [uint]) -> &'r [uint] { v }
+fn subslice1<'r>(v: &'r [usize]) -> &'r [usize] { v }
-fn both<'r>(v: &'r [uint]) -> &'r [uint] {
+fn both<'r>(v: &'r [usize]) -> &'r [usize] {
subslice1(subslice1(v))
}
// pretty-expanded FIXME #23616
-struct Foo(int);
+struct Foo(isize);
pub fn main() {
// Here the lifetime of the `&` should be at least the
// block, since a ref binding is created to the interior.
}
pub trait Decodable<'v, D: Decoder<'v>>
- : marker::PhantomFn<(), &'v int>
+ : marker::PhantomFn<(), &'v isize>
{
fn decode(d: &mut D) -> Self;
}
#![feature(box_syntax)]
trait Trait<'a> {
- fn long(&'a self) -> int;
- fn short<'b>(&'b self) -> int;
+ fn long(&'a self) -> isize;
+ fn short<'b>(&'b self) -> isize;
}
-fn poly_invoke<'c, T: Trait<'c>>(x: &'c T) -> (int, int) {
+fn poly_invoke<'c, T: Trait<'c>>(x: &'c T) -> (isize, isize) {
let l = x.long();
let s = x.short();
(l,s)
}
-fn object_invoke1<'d>(x: &'d Trait<'d>) -> (int, int) {
+fn object_invoke1<'d>(x: &'d Trait<'d>) -> (isize, isize) {
let l = x.long();
let s = x.short();
(l,s)
f: &'e (Trait<'e>+'e)
}
-fn field_invoke1<'f, 'g>(x: &'g Struct1<'f>) -> (int,int) {
+fn field_invoke1<'f, 'g>(x: &'g Struct1<'f>) -> (isize,isize) {
let l = x.f.long();
let s = x.f.short();
(l,s)
f: &'h (Trait<'i>+'h)
}
-fn object_invoke2<'j, 'k>(x: &'k Trait<'j>) -> int {
+fn object_invoke2<'j, 'k>(x: &'k Trait<'j>) -> isize {
x.short()
}
-fn field_invoke2<'l, 'm, 'n>(x: &'n Struct2<'l,'m>) -> int {
+fn field_invoke2<'l, 'm, 'n>(x: &'n Struct2<'l,'m>) -> isize {
x.f.short()
}
RefMakerTrait::mk(t)
}
-impl<'s> Trait<'s> for (int,int) {
- fn long(&'s self) -> int {
+impl<'s> Trait<'s> for (isize,isize) {
+ fn long(&'s self) -> isize {
let &(x,_) = self;
x
}
- fn short<'b>(&'b self) -> int {
+ fn short<'b>(&'b self) -> isize {
let &(_,y) = self;
y
}
impl<'t> MakerTrait for Box<Trait<'t>+'static> {
fn mk() -> Box<Trait<'t>+'static> {
- let tup: Box<(int, int)> = box() (4,5);
+ let tup: Box<(isize, isize)> = box() (4,5);
tup as Box<Trait>
}
}
enum List<'l> {
- Cons(int, &'l List<'l>),
+ Cons(isize, &'l List<'l>),
Null
}
impl<'l> List<'l> {
- fn car<'m>(&'m self) -> int {
+ fn car<'m>(&'m self) -> isize {
match self {
&List::Cons(car, _) => car,
&List::Null => panic!(),
// pretty-expanded FIXME #23616
trait GetRef<'a> {
- fn get(&self) -> &'a int;
+ fn get(&self) -> &'a isize;
}
#[derive(Copy)]
struct Box<'a> {
- t: &'a int
+ t: &'a isize
}
impl<'a> GetRef<'a> for Box<'a> {
- fn get(&self) -> &'a int {
+ fn get(&self) -> &'a isize {
self.t
}
}
impl<'a> Box<'a> {
- fn add<'b,G:GetRef<'b>>(&self, g2: G) -> int {
+ fn add<'b,G:GetRef<'b>>(&self, g2: G) -> isize {
*self.t + *g2.get()
}
}
}
}
-fn add<'a,G:GetRef<'a, int>>(g1: G, g2: G) -> int {
+fn add<'a,G:GetRef<'a, isize>>(g1: G, g2: G) -> isize {
*g1.get() + *g2.get()
}
}
}
-fn add<'a,G:Get<&'a int>>(g1: G, g2: G) -> int {
+fn add<'a,G:Get<&'a isize>>(g1: G, g2: G) -> isize {
*g1.get() + *g2.get()
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn foo(x: &uint) -> &uint { x }
-fn bar(x: &uint) -> uint { *x }
+fn foo(x: &usize) -> &usize { x }
+fn bar(x: &usize) -> usize { *x }
pub fn main() {
let p: Box<_> = box 3;
// pretty-expanded FIXME #23616
struct Foo {
- f: uint
+ f: usize
}
impl Foo {
// that `x` is in.
// pretty-expanded FIXME #23616
-fn has_same_region(f: Box<for<'a> FnMut(&'a int, Box<FnMut(&'a int)>)>) {
+fn has_same_region(f: Box<for<'a> FnMut(&'a isize, Box<FnMut(&'a isize)>)>) {
// `f` should be the type that `wants_same_region` wants, but
// right now the compiler complains that it isn't.
wants_same_region(f);
}
-fn wants_same_region(_f: Box<for<'b> FnMut(&'b int, Box<FnMut(&'b int)>)>) {
+fn wants_same_region(_f: Box<for<'b> FnMut(&'b isize, Box<FnMut(&'b isize)>)>) {
}
pub fn main() {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
// Should pass region checking.
-fn ok(f: Box<FnMut(&uint)>) {
- // Here, g is a function that can accept a uint pointer with
- // lifetime r, and f is a function that can accept a uint pointer
+fn ok(f: Box<FnMut(&usize)>) {
+ // Here, g is a function that can accept a usize pointer with
+ // lifetime r, and f is a function that can accept a usize pointer
// with any lifetime. The assignment g = f should be OK (i.e.,
// f's type should be a subtype of g's type), because f can be
// used in any context that expects g's type. But this currently
// fails.
- let mut g: Box<for<'r> FnMut(&'r uint)> = Box::new(|x| { });
+ let mut g: Box<for<'r> FnMut(&'r usize)> = Box::new(|x| { });
g = f;
}
// This version is the same as above, except that here, g's type is
// inferred.
-fn ok_inferred(f: Box<FnMut(&uint)>) {
- let mut g: Box<for<'r> FnMut(&'r uint)> = Box::new(|_| {});
+fn ok_inferred(f: Box<FnMut(&usize)>) {
+ let mut g: Box<for<'r> FnMut(&'r usize)> = Box::new(|_| {});
g = f;
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct Point {x: int, y: int}
+struct Point {x: isize, y: isize}
-fn x_coord(p: &Point) -> &int {
+fn x_coord(p: &Point) -> &isize {
return &p.x;
}
// pretty-expanded FIXME #23616
-fn takes_two(x: &int, y: &int) -> int { *x + *y }
+fn takes_two(x: &isize, y: &isize) -> isize { *x + *y }
-fn with<T, F>(f: F) -> T where F: FnOnce(&int) -> T {
+fn with<T, F>(f: F) -> T where F: FnOnce(&isize) -> T {
f(&20)
}
-fn has_one<'a>(x: &'a int) -> int {
+fn has_one<'a>(x: &'a isize) -> isize {
with(|y| takes_two(x, y))
}
// pretty-expanded FIXME #23616
-fn takes_two(x: &int, y: &int) -> int { *x + *y }
+fn takes_two(x: &isize, y: &isize) -> isize { *x + *y }
-fn has_two<'a,'b>(x: &'a int, y: &'b int) -> int {
+fn has_two<'a,'b>(x: &'a isize, y: &'b isize) -> isize {
takes_two(x, y)
}
// pretty-expanded FIXME #23616
struct boxed_int<'a> {
- f: &'a int,
+ f: &'a isize,
}
-fn max<'r>(bi: &'r boxed_int, f: &'r int) -> int {
+fn max<'r>(bi: &'r boxed_int, f: &'r isize) -> isize {
if *bi.f > *f {*bi.f} else {*f}
}
-fn with(bi: &boxed_int) -> int {
+fn with(bi: &boxed_int) -> isize {
let i = 22;
max(bi, &i)
}
// pretty-expanded FIXME #23616
-fn foo<'a,'b>(x: &'a &'b mut int) -> &'a int {
- let y = &*x; // should be inferred to have type &'a &'b mut int...
+fn foo<'a,'b>(x: &'a &'b mut isize) -> &'a isize {
+ let y = &*x; // should be inferred to have type &'a &'b mut isize...
- // ...because if we inferred, say, &'x &'b mut int where 'x <= 'a,
+ // ...because if we inferred, say, &'x &'b mut isize where 'x <= 'a,
// this reborrow would be illegal:
&**y
}
// except according to those terms.
-// check that the &int here does not cause us to think that `foo`
+// check that the &isize here does not cause us to think that `foo`
// contains region pointers
// pretty-expanded FIXME #23616
-struct foo(Box<FnMut(&int)+'static>);
+struct foo(Box<FnMut(&isize)+'static>);
fn take_foo<T:'static>(x: T) {}
// pretty-expanded FIXME #23616
-static i: uint = 3;
+static i: usize = 3;
fn foo<F:FnOnce()+'static>(_: F) {}
-fn read(_: uint) { }
+fn read(_: usize) { }
pub fn main() {
let x = &i;
foo(move|| {
pub fn main() {
fn explicit() {
- fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box<for<'a> FnMut(&'a int)>) {}
- test(Some(box |_f: Box<for<'a> FnMut(&'a int)>| {}));
+ fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box<for<'a> FnMut(&'a isize)>) {}
+ test(Some(box |_f: Box<for<'a> FnMut(&'a isize)>| {}));
}
// The code below is shorthand for the code above (and more likely
// to represent what one encounters in practice).
fn implicit() {
- fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box< FnMut(& int)>) {}
- test(Some(box |_f: Box< FnMut(& int)>| {}));
+ fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box< FnMut(& isize)>) {}
+ test(Some(box |_f: Box< FnMut(& isize)>| {}));
}
explicit();
static C: E = E::V;
}
- f::<int>(&mut None);
+ f::<isize>(&mut None);
}
#![allow(dead_code)]
-fn with<'a, F>(_: F) where F: FnOnce(&'a Vec<int>) -> &'a Vec<int> { }
+fn with<'a, F>(_: F) where F: FnOnce(&'a Vec<isize>) -> &'a Vec<isize> { }
fn foo() {
with(|&ref ints| ints);
type_table: HashMap<NodeId, Type<'tcx>>,
ast_arena: &'ast AstArena<'ast>,
- ast_counter: uint,
+ ast_counter: usize,
}
impl<'tcx,'ast> TypeContext<'tcx, 'ast> {
#[derive(Copy, PartialEq, Eq, Hash)]
struct NodeId {
- id: uint
+ id: usize
}
type Ast<'ast> = &'ast AstStructure<'ast>;
#[derive(Copy)]
enum AstKind<'ast> {
ExprInt,
- ExprVar(uint),
+ ExprVar(usize),
ExprLambda(Ast<'ast>),
}
}
struct Ccx {
- x: int
+ x: isize
}
fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
// pretty-expanded FIXME #23616
enum roption<'a> {
- a, b(&'a uint)
+ a, b(&'a usize)
}
-fn mk(cond: bool, ptr: &uint) -> roption {
+fn mk(cond: bool, ptr: &usize) -> roption {
if cond {roption::a} else {roption::b(ptr)}
}
// pretty-expanded FIXME #23616
-fn region_identity(x: &uint) -> &uint { x }
+fn region_identity(x: &usize) -> &usize { x }
fn apply<T, F>(t: T, f: F) -> T where F: FnOnce(T) -> T { f(t) }
-fn parameterized(x: &uint) -> uint {
+fn parameterized(x: &usize) -> usize {
let z = apply(x, ({|y|
region_identity(y)
}));
// pretty-expanded FIXME #23616
-fn foo(x: &int) {
+fn foo(x: &isize) {
let a = 1;
let mut z = x;
z = &a;
// pretty-expanded FIXME #23616
-fn foo(x: &int) {
+fn foo(x: &isize) {
let a = 1;
match x {
mut z => {
#![feature(box_syntax)]
struct Ctxt<'tcx> {
- x: &'tcx Vec<int>
+ x: &'tcx Vec<isize>
}
struct Foo<'a,'tcx:'a> {
}
impl<'a,'tcx> Foo<'a,'tcx> {
- fn bother(&mut self) -> int {
+ fn bother(&mut self) -> isize {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
self.elaborate_bounds(Box::new(|this| {
// (*) Here: type of `this` is `&'f0 Foo<&'f1, '_2>`,
}))
}
- fn foo(&mut self) -> int {
+ fn foo(&mut self) -> isize {
22
}
fn elaborate_bounds(
&mut self,
- mut mk_cand: Box<for<'b> FnMut(&mut Foo<'b, 'tcx>) -> int>)
- -> int
+ mut mk_cand: Box<for<'b> FnMut(&mut Foo<'b, 'tcx>) -> isize>)
+ -> isize
{
mk_cand(self)
}
// except according to those terms.
struct Clam<'a> {
- chowder: &'a int
+ chowder: &'a isize
}
trait get_chowder<'a> {
- fn get_chowder(&self) -> &'a int;
+ fn get_chowder(&self) -> &'a isize;
}
impl<'a> get_chowder<'a> for Clam<'a> {
- fn get_chowder(&self) -> &'a int { return self.chowder; }
+ fn get_chowder(&self) -> &'a isize { return self.chowder; }
}
pub fn main() {
// except according to those terms.
enum int_wrapper<'a> {
- int_wrapper_ctor(&'a int)
+ int_wrapper_ctor(&'a isize)
}
pub fn main() {
let x = 3;
let y = int_wrapper::int_wrapper_ctor(&x);
- let mut z : ∫
+ let mut z : &isize;
match y {
int_wrapper::int_wrapper_ctor(zz) => { z = zz; }
}
// except according to those terms.
pub fn main() {
- let mut x: int = 3;
- let y: &mut int = &mut x;
+ let mut x: isize = 3;
+ let y: &mut isize = &mut x;
*y = 5;
println!("{}", *y);
}
// pretty-expanded FIXME #23616
struct Contravariant<'a> {
- f: &'a int
+ f: &'a isize
}
fn use_<'a>(c: Contravariant<'a>) {
// if 'call <= 'a, which is true, so no error.
collapse(&x, c);
- fn collapse<'b>(x: &'b int, c: Contravariant<'b>) { }
+ fn collapse<'b>(x: &'b isize, c: Contravariant<'b>) { }
}
pub fn main() {}
// pretty-expanded FIXME #23616
struct Covariant<'a> {
- f: extern "Rust" fn(&'a int)
+ f: extern "Rust" fn(&'a isize)
}
fn use_<'a>(c: Covariant<'a>) {
// pretty-expanded FIXME #23616
-static FOO: [int; 4] = [32; 4];
-static BAR: [int; 4] = [32, 32, 32, 32];
+static FOO: [isize; 4] = [32; 4];
+static BAR: [isize; 4] = [32, 32, 32, 32];
pub fn main() {
assert!(FOO == BAR);
// pretty-expanded FIXME #23616
-const foo: int = 4 >> 1;
+const foo: isize = 4 >> 1;
enum bs { thing = foo }
-pub fn main() { assert!((bs::thing as int == foo)); }
+pub fn main() { assert!((bs::thing as isize == foo)); }
#[derive(Debug)]
struct r<'a> {
- i: &'a Cell<int>,
+ i: &'a Cell<isize>,
}
#[unsafe_destructor]
}
}
-fn r(i: &Cell<int>) -> r {
+fn r(i: &Cell<isize>) -> r {
r {
i: i
}
use std::cell::Cell;
struct shrinky_pointer<'a> {
- i: &'a Cell<int>,
+ i: &'a Cell<isize>,
}
#[unsafe_destructor]
}
impl<'a> shrinky_pointer<'a> {
- pub fn look_at(&self) -> int { return self.i.get(); }
+ pub fn look_at(&self) -> isize { return self.i.get(); }
}
-fn shrinky_pointer(i: &Cell<int>) -> shrinky_pointer {
+fn shrinky_pointer(i: &Cell<isize>) -> shrinky_pointer {
shrinky_pointer {
i: i
}
fn my_err(s: String) -> ! { println!("{}", s); panic!(); }
-fn okay(i: uint) -> int {
+fn okay(i: usize) -> isize {
if i == 3 {
my_err("I don't like three".to_string());
} else {
fn f<T>() -> option<T> { return option::none; }
-pub fn main() { f::<int>(); }
+pub fn main() { f::<isize>(); }
// not the surrounding function.
// pretty-expanded FIXME #23616
-static mut calls: uint = 0;
+static mut calls: usize = 0;
fn surrounding() {
- let return_works = |n: int| {
+ let return_works = |n: isize| {
unsafe { calls += 1 }
if n >= 0 { return; }
return_works(10);
return_works(20);
- let return_works_proc = |n: int| {
+ let return_works_proc = |n: isize| {
unsafe { calls += 1 }
if n >= 0 { return; }
use std::thunk::Thunk;
#[start]
-fn start(argc: int, argv: *const *const u8) -> int {
+fn start(argc: isize, argv: *const *const u8) -> isize {
if argc > 1 {
unsafe {
match **argv.offset(1) {
}
let args = unsafe {
- (0..argc as uint).map(|i| {
- let ptr = *argv.offset(i as int) as *const _;
+ (0..argc as usize).map(|i| {
+ let ptr = *argv.offset(i as isize) as *const _;
ffi::c_str_to_bytes(&ptr).to_vec()
}).collect::<Vec<_>>()
};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// exec-env:RUST_LOG=rust-log-filter/foo
+// exec-env:RUST_LOG=rust_log_filter/foo
// pretty-expanded FIXME #23616
fn main() {
let args: Vec<String> = env::args().collect();
if args.len() > 1 && args[1] == "segfault" {
- unsafe { *(0 as *mut int) = 1 }; // trigger a segfault
+ unsafe { *(0 as *mut isize) = 1 }; // trigger a segfault
} else {
let segfault = Command::new(&args[0]).arg("segfault").output().unwrap();
assert!(!segfault.status.success());
fn dummy(&self, x: X) { }
}
-impl Bar<int> for Box<Baz<int>> {
+impl Bar<isize> for Box<Baz<isize>> {
fn bar(_x: Self, _y: &Self, _z: Box<Self>) -> Self {
box Baz { f: 42 }
}
fn main() {
let _: Foo = Foo::foo(Foo, &Foo, box Foo);
- let _: Box<Baz<int>> = Bar::bar(box Baz { f: 42 },
+ let _: Box<Baz<isize>> = Bar::bar(box Baz { f: 42 },
&box Baz { f: 42 },
box box Baz { f: 42 });
}
#![feature(box_syntax)]
struct X {
- a: int
+ a: isize
}
trait Changer : Sized {
self
}
- fn set_to(&mut self, a: int);
+ fn set_to(&mut self, a: isize);
}
impl Changer for X {
- fn set_to(&mut self, a: int) {
+ fn set_to(&mut self, a: isize) {
self.a = a;
}
}
#[derive(Copy)]
struct Value {
- n: int
+ n: isize
}
impl Value {
mod a {
pub mod b {
pub mod a {
- pub fn foo() -> int { return 1; }
+ pub fn foo() -> isize { return 1; }
}
}
}
}
struct S {
- x: int
+ x: isize
}
impl MyTrait for S {
use std::sync::mpsc::channel;
struct test {
- f: int,
+ f: isize,
}
impl Drop for test {
fn drop(&mut self) {}
}
-fn test(f: int) -> test {
+fn test(f: isize) -> test {
test {
f: f
}
type SendStr = Cow<'static, str>;
pub fn main() {
- let mut map: HashMap<SendStr, uint> = HashMap::new();
+ let mut map: HashMap<SendStr, usize> = HashMap::new();
assert!(map.insert("foo".into_cow(), 42).is_none());
assert!(map.insert("foo".to_string().into_cow(), 42).is_some());
assert!(map.insert("foo".into_cow(), 42).is_some());
type SendStr = Cow<'static, str>;
pub fn main() {
- let mut map: BTreeMap<SendStr, uint> = BTreeMap::new();
+ let mut map: BTreeMap<SendStr, usize> = BTreeMap::new();
assert!(map.insert("foo".into_cow(), 42).is_none());
assert!(map.insert("foo".to_string().into_cow(), 42).is_some());
assert!(map.insert("foo".into_cow(), 42).is_some());
use std::sync::mpsc::channel;
struct foo {
- i: int,
+ i: isize,
j: char,
}
-fn foo(i:int, j: char) -> foo {
+fn foo(i:isize, j: char) -> foo {
foo {
i: i,
j: j
// pretty-expanded FIXME #23616
-fn test<F>(f: F) -> uint where F: FnOnce(uint) -> uint {
+fn test<F>(f: F) -> usize where F: FnOnce(usize) -> usize {
return f(22);
}
pub fn main() { test05(); }
-fn test05_start<F:FnOnce(int)>(f: F) {
+fn test05_start<F:FnOnce(isize)>(f: F) {
f(22);
}
fn test05() {
let three: Box<_> = box 3;
- let fn_to_send = move|n:int| {
+ let fn_to_send = move|n:isize| {
println!("{}", *three + n); // will copy x into the closure
assert_eq!(*three, 3);
};
extern crate sepcomp_cci_lib;
use sepcomp_cci_lib::{cci_fn, CCI_STATIC};
-fn call1() -> uint {
+fn call1() -> usize {
cci_fn() + CCI_STATIC
}
mod a {
use sepcomp_cci_lib::{cci_fn, CCI_STATIC};
- pub fn call2() -> uint {
+ pub fn call2() -> usize {
cci_fn() + CCI_STATIC
}
}
mod b {
use sepcomp_cci_lib::{cci_fn, CCI_STATIC};
- pub fn call3() -> uint {
+ pub fn call3() -> usize {
cci_fn() + CCI_STATIC
}
}
// pretty-expanded FIXME #23616
-#[link(name = "sepcomp-extern-lib")]
+#[link(name = "sepcomp_extern_lib")]
extern {
#[allow(ctypes)]
- fn foo() -> uint;
+ fn foo() -> usize;
}
-fn call1() -> uint {
+fn call1() -> usize {
unsafe { foo() }
}
mod a {
- pub fn call2() -> uint {
+ pub fn call2() -> usize {
unsafe { ::foo() }
}
}
mod b {
- pub fn call3() -> uint {
+ pub fn call3() -> usize {
unsafe { ::foo() }
}
}
// compilation unit as the top-level module.
// pretty-expanded FIXME #23616
-fn pad() -> uint { 0 }
+fn pad() -> usize { 0 }
mod b {
- pub fn three() -> uint {
+ pub fn three() -> usize {
::one() + ::a::two()
}
}
mod a {
- pub fn two() -> uint {
+ pub fn two() -> usize {
::one() + ::one()
}
}
-fn one() -> uint {
+fn one() -> usize {
1
}
// compilation unit as the top-level module.
// pretty-expanded FIXME #23616
-fn one() -> uint { 1 }
+fn one() -> usize { 1 }
mod a {
- pub fn two() -> uint {
+ pub fn two() -> usize {
::one() + ::one()
}
}
mod b {
- pub fn three() -> uint {
+ pub fn three() -> usize {
::one() + ::a::two()
}
}
// pretty-expanded FIXME #23616
-fn pad() -> uint { 0 }
+fn pad() -> usize { 0 }
-const ONE: uint = 1;
+const ONE: usize = 1;
mod b {
// Separate compilation always switches to the LLVM module with the fewest
// instructions. Make sure we have some instructions in this module so
// that `a` and `b` don't go into the same compilation unit.
- fn pad() -> uint { 0 }
+ fn pad() -> usize { 0 }
- pub static THREE: uint = ::ONE + ::a::TWO;
+ pub static THREE: usize = ::ONE + ::a::TWO;
}
mod a {
- fn pad() -> uint { 0 }
+ fn pad() -> usize { 0 }
- pub const TWO: uint = ::ONE + ::ONE;
+ pub const TWO: usize = ::ONE + ::ONE;
}
fn main() {
use std::thread;
-fn pad() -> uint { 0 }
+fn pad() -> usize { 0 }
mod a {
pub fn f() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn foo(c: Vec<int> ) {
- let a: int = 5;
- let mut b: Vec<int> = Vec::new();
+fn foo(c: Vec<isize> ) {
+ let a: isize = 5;
+ let mut b: Vec<isize> = Vec::new();
- match t::none::<int> {
- t::some::<int>(_) => {
+ match t::none::<isize> {
+ t::some::<isize>(_) => {
for _i in &c {
println!("{}", a);
let a = 17;
}
fn test_expr() {
- let v10 = 10 as uint;
+ let v10 = 10 as usize;
let v4 = 4 as u8;
let v2 = 2 as u8;
- assert_eq!(v10 >> v2 as uint, v2 as uint);
- assert_eq!(v10 << v4 as uint, 160 as uint);
+ assert_eq!(v10 >> v2 as usize, v2 as usize);
+ assert_eq!(v10 << v4 as usize, 160 as usize);
let v10 = 10 as u8;
- let v4 = 4 as uint;
- let v2 = 2 as uint;
- assert_eq!(v10 >> v2 as uint, v2 as u8);
- assert_eq!(v10 << v4 as uint, 160 as u8);
+ let v4 = 4 as usize;
+ let v2 = 2 as usize;
+ assert_eq!(v10 >> v2 as usize, v2 as u8);
+ assert_eq!(v10 << v4 as usize, 160 as u8);
- let v10 = 10 as int;
+ let v10 = 10 as isize;
let v4 = 4 as i8;
let v2 = 2 as i8;
- assert_eq!(v10 >> v2 as uint, v2 as int);
- assert_eq!(v10 << v4 as uint, 160 as int);
+ assert_eq!(v10 >> v2 as usize, v2 as isize);
+ assert_eq!(v10 << v4 as usize, 160 as isize);
let v10 = 10 as i8;
- let v4 = 4 as int;
- let v2 = 2 as int;
- assert_eq!(v10 >> v2 as uint, v2 as i8);
- assert_eq!(v10 << v4 as uint, 160 as i8);
+ let v4 = 4 as isize;
+ let v2 = 2 as isize;
+ assert_eq!(v10 >> v2 as usize, v2 as i8);
+ assert_eq!(v10 << v4 as usize, 160 as i8);
- let v10 = 10 as uint;
- let v4 = 4 as int;
- let v2 = 2 as int;
- assert_eq!(v10 >> v2 as uint, v2 as uint);
- assert_eq!(v10 << v4 as uint, 160 as uint);
+ let v10 = 10 as usize;
+ let v4 = 4 as isize;
+ let v2 = 2 as isize;
+ assert_eq!(v10 >> v2 as usize, v2 as usize);
+ assert_eq!(v10 << v4 as usize, 160 as usize);
}
fn test_const() {
- static r1_1: uint = 10_usize >> 2_usize;
- static r2_1: uint = 10_usize << 4_usize;
- assert_eq!(r1_1, 2 as uint);
- assert_eq!(r2_1, 160 as uint);
+ static r1_1: usize = 10_usize >> 2_usize;
+ static r2_1: usize = 10_usize << 4_usize;
+ assert_eq!(r1_1, 2 as usize);
+ assert_eq!(r2_1, 160 as usize);
static r1_2: u8 = 10u8 >> 2_usize;
static r2_2: u8 = 10u8 << 4_usize;
assert_eq!(r1_2, 2 as u8);
assert_eq!(r2_2, 160 as u8);
- static r1_3: int = 10 >> 2_usize;
- static r2_3: int = 10 << 4_usize;
- assert_eq!(r1_3, 2 as int);
- assert_eq!(r2_3, 160 as int);
+ static r1_3: isize = 10 >> 2_usize;
+ static r2_3: isize = 10 << 4_usize;
+ assert_eq!(r1_3, 2 as isize);
+ assert_eq!(r2_3, 160 as isize);
static r1_4: i8 = 10i8 >> 2_usize;
static r2_4: i8 = 10i8 << 4_usize;
assert_eq!(r1_4, 2 as i8);
assert_eq!(r2_4, 160 as i8);
- static r1_5: uint = 10_usize >> 2_usize;
- static r2_5: uint = 10_usize << 4_usize;
- assert_eq!(r1_5, 2 as uint);
- assert_eq!(r2_5, 160 as uint);
+ static r1_5: usize = 10_usize >> 2_usize;
+ static r2_5: usize = 10_usize << 4_usize;
+ assert_eq!(r1_5, 2 as usize);
+ assert_eq!(r2_5, 160 as usize);
}
let args: Vec<String> = env::args().collect();
if args.len() >= 2 && args[1] == "signal" {
// Raise a segfault.
- unsafe { *(0 as *mut int) = 0; }
+ unsafe { *(0 as *mut isize) = 0; }
} else {
let status = Command::new(&args[0]).arg("signal").status().unwrap();
// Windows does not have signal, so we get exit status 0xC0000028 (STATUS_BAD_STACK).
enum test { thing = -5 >> 1_usize }
pub fn main() {
- assert_eq!(test::thing as int, -3);
+ assert_eq!(test::thing as isize, -3);
}
enum clam<T> { a(T), }
-pub fn main() { let c = clam::a(2); match c { clam::a::<int>(_) => { } } }
+pub fn main() { let c = clam::a(2); match c { clam::a::<isize>(_) => { } } }
enum opt<T> { none, some(T) }
pub fn main() {
- let x = opt::none::<int>;
+ let x = opt::none::<isize>;
match x {
- opt::none::<int> => { println!("hello world"); }
+ opt::none::<isize> => { println!("hello world"); }
opt::some(_) => { }
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-enum clam<T> { a(T, int), b, }
+enum clam<T> { a(T, isize), b, }
fn uhoh<T>(v: Vec<clam<T>> ) {
match v[1] {
}
pub fn main() {
- let v: Vec<clam<int>> = vec!(clam::b::<int>, clam::b::<int>, clam::a::<int>(42, 17));
- uhoh::<int>(v);
+ let v: Vec<clam<isize>> = vec!(clam::b::<isize>, clam::b::<isize>, clam::a::<isize>(42, 17));
+ uhoh::<isize>(v);
}
// pretty-expanded FIXME #23616
fn main() {
- let x: &[int] = &[1, 2, 3, 4, 5];
- let cmp: &[int] = &[1, 2, 3, 4, 5];
+ let x: &[isize] = &[1, 2, 3, 4, 5];
+ let cmp: &[isize] = &[1, 2, 3, 4, 5];
assert!(&x[..] == cmp);
- let cmp: &[int] = &[3, 4, 5];
+ let cmp: &[isize] = &[3, 4, 5];
assert!(&x[2..] == cmp);
- let cmp: &[int] = &[1, 2, 3];
+ let cmp: &[isize] = &[1, 2, 3];
assert!(&x[..3] == cmp);
- let cmp: &[int] = &[2, 3, 4];
+ let cmp: &[isize] = &[2, 3, 4];
assert!(&x[1..4] == cmp);
- let x: Vec<int> = vec![1, 2, 3, 4, 5];
- let cmp: &[int] = &[1, 2, 3, 4, 5];
+ let x: Vec<isize> = vec![1, 2, 3, 4, 5];
+ let cmp: &[isize] = &[1, 2, 3, 4, 5];
assert!(&x[..] == cmp);
- let cmp: &[int] = &[3, 4, 5];
+ let cmp: &[isize] = &[3, 4, 5];
assert!(&x[2..] == cmp);
- let cmp: &[int] = &[1, 2, 3];
+ let cmp: &[isize] = &[1, 2, 3];
assert!(&x[..3] == cmp);
- let cmp: &[int] = &[2, 3, 4];
+ let cmp: &[isize] = &[2, 3, 4];
assert!(&x[1..4] == cmp);
- let x: &mut [int] = &mut [1, 2, 3, 4, 5];
+ let x: &mut [isize] = &mut [1, 2, 3, 4, 5];
{
- let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
+ let cmp: &mut [isize] = &mut [1, 2, 3, 4, 5];
assert!(&mut x[..] == cmp);
}
{
- let cmp: &mut [int] = &mut [3, 4, 5];
+ let cmp: &mut [isize] = &mut [3, 4, 5];
assert!(&mut x[2..] == cmp);
}
{
- let cmp: &mut [int] = &mut [1, 2, 3];
+ let cmp: &mut [isize] = &mut [1, 2, 3];
assert!(&mut x[..3] == cmp);
}
{
- let cmp: &mut [int] = &mut [2, 3, 4];
+ let cmp: &mut [isize] = &mut [2, 3, 4];
assert!(&mut x[1..4] == cmp);
}
- let mut x: Vec<int> = vec![1, 2, 3, 4, 5];
+ let mut x: Vec<isize> = vec![1, 2, 3, 4, 5];
{
- let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
+ let cmp: &mut [isize] = &mut [1, 2, 3, 4, 5];
assert!(&mut x[..] == cmp);
}
{
- let cmp: &mut [int] = &mut [3, 4, 5];
+ let cmp: &mut [isize] = &mut [3, 4, 5];
assert!(&mut x[2..] == cmp);
}
{
- let cmp: &mut [int] = &mut [1, 2, 3];
+ let cmp: &mut [isize] = &mut [1, 2, 3];
assert!(&mut x[..3] == cmp);
}
{
- let cmp: &mut [int] = &mut [2, 3, 4];
+ let cmp: &mut [isize] = &mut [2, 3, 4];
assert!(&mut x[1..4] == cmp);
}
}
struct Foo;
-static mut DTOR_COUNT: int = 0;
+static mut DTOR_COUNT: isize = 0;
impl Drop for Foo {
fn drop(&mut self) { unsafe { DTOR_COUNT += 1; } }
struct Foo;
-static mut DTOR_COUNT: int = 0;
+static mut DTOR_COUNT: isize = 0;
impl Drop for Foo {
fn drop(&mut self) { unsafe { DTOR_COUNT += 1; } }
}
-fn bar() -> uint {
+fn bar() -> usize {
panic!();
}
extern crate core;
use core::ops::{Index, IndexMut, Range, RangeTo, RangeFrom, RangeFull};
-static mut COUNT: uint = 0;
+static mut COUNT: usize = 0;
struct Foo;
#[start]
#[no_stack_check]
-fn main(_: int, _: *const *const u8) -> int {
+fn main(_: isize, _: *const *const u8) -> isize {
unsafe {
- let (ptr, _): (*const u8, uint) = transmute("Hello!\0");
+ let (ptr, _): (*const u8, usize) = transmute("Hello!\0");
puts(ptr);
}
return 0;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(std_misc)]
+use std::thread;
-use std::thread::Thread;
-
-fn x(s: String, n: int) {
+fn x(s: String, n: isize) {
println!("{}", s);
println!("{}", n);
}
pub fn main() {
- let _t = Thread::spawn(|| x("hello from first spawned fn".to_string(), 65) );
- let _t = Thread::spawn(|| x("hello from second spawned fn".to_string(), 66) );
- let _t = Thread::spawn(|| x("hello from third spawned fn".to_string(), 67) );
- let mut i: int = 30;
+ let _t = thread::scoped(|| x("hello from first spawned fn".to_string(), 65) );
+ let _t = thread::scoped(|| x("hello from second spawned fn".to_string(), 66) );
+ let _t = thread::scoped(|| x("hello from third spawned fn".to_string(), 67) );
+ let mut i = 30;
while i > 0 {
i = i - 1;
println!("parent sleeping");
- Thread::yield_now();
+ thread::yield_now();
}
}
use std::thread;
use std::sync::mpsc::{channel, Sender};
-type ctx = Sender<int>;
+type ctx = Sender<isize>;
fn iotask(_tx: &ctx, ip: String) {
assert_eq!(ip, "localhost".to_string());
}
pub fn main() {
- let (tx, _rx) = channel::<int>();
+ let (tx, _rx) = channel::<isize>();
let t = thread::spawn(move|| iotask(&tx, "localhost".to_string()) );
t.join().ok().unwrap();
}
thread::spawn(move|| child(10)).join().ok().unwrap();
}
-fn child(i: int) { println!("{}", i); assert!((i == 10)); }
+fn child(i: isize) { println!("{}", i); assert!((i == 10)); }
t.join().ok().unwrap(); // forget Err value, since it doesn't implement Debug
}
-fn child(args: (int, int, int, int, int, int, int, int, int)) {
+fn child(args: (isize, isize, isize, isize, isize, isize, isize, isize, isize)) {
let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
println!("{}", i1);
println!("{}", i2);
// pretty-expanded FIXME #23616
pub fn main() {
- let foo: int = 1;
- assert_eq!(&foo as *const int, &foo as *const int);
+ let foo: isize = 1;
+ assert_eq!(&foo as *const isize, &foo as *const isize);
}
// pretty-expanded FIXME #23616
-extern crate "static_fn_inline_xc_aux" as mycore;
+extern crate static_fn_inline_xc_aux as mycore;
use mycore::num;
// pretty-expanded FIXME #23616
-extern crate "static_fn_trait_xc_aux" as mycore;
+extern crate static_fn_trait_xc_aux as mycore;
use mycore::num;
// aux-build:static-function-pointer-aux.rs
// pretty-expanded FIXME #23616
-extern crate "static-function-pointer-aux" as aux;
+extern crate static_function_pointer_aux as aux;
-fn f(x: int) -> int { x }
+fn f(x: isize) -> isize { x }
pub fn main() {
assert_eq!(aux::F(42), -42);
// pretty-expanded FIXME #23616
-fn f(x: int) -> int { x }
-fn g(x: int) -> int { 2 * x }
+fn f(x: isize) -> isize { x }
+fn g(x: isize) -> isize { 2 * x }
-static F: fn(int) -> int = f;
-static mut G: fn(int) -> int = f;
+static F: fn(isize) -> isize = f;
+static mut G: fn(isize) -> isize = f;
pub fn main() {
assert_eq!(F(42), 42);
// pretty-expanded FIXME #23616
pub trait plus {
- fn plus(&self) -> int;
+ fn plus(&self) -> isize;
}
mod a {
use plus;
- impl plus for uint { fn plus(&self) -> int { *self as int + 20 } }
+ impl plus for usize { fn plus(&self) -> isize { *self as isize + 20 } }
}
mod b {
use plus;
- impl plus for String { fn plus(&self) -> int { 200 } }
+ impl plus for String { fn plus(&self) -> isize { 200 } }
}
trait uint_utils {
fn str(&self) -> String;
- fn multi<F>(&self, f: F) where F: FnMut(uint);
+ fn multi<F>(&self, f: F) where F: FnMut(usize);
}
-impl uint_utils for uint {
+impl uint_utils for usize {
fn str(&self) -> String {
self.to_string()
}
- fn multi<F>(&self, mut f: F) where F: FnMut(uint) {
+ fn multi<F>(&self, mut f: F) where F: FnMut(usize) {
let mut c = 0_usize;
while c < *self { f(c); c += 1_usize; }
}
}
trait vec_utils<T> {
- fn length_(&self, ) -> uint;
+ fn length_(&self, ) -> usize;
fn iter_<F>(&self, f: F) where F: FnMut(&T);
fn map_<U, F>(&self, f: F) -> Vec<U> where F: FnMut(&T) -> U;
}
impl<T> vec_utils<T> for Vec<T> {
- fn length_(&self) -> uint { self.len() }
+ fn length_(&self) -> usize { self.len() }
fn iter_<F>(&self, mut f: F) where F: FnMut(&T) { for x in self { f(x); } }
fn map_<U, F>(&self, mut f: F) -> Vec<U> where F: FnMut(&T) -> U {
let mut r = Vec::new();
assert_eq!((vec!(1)).length_().str(), "1".to_string());
let vect = vec!(3, 4).map_(|a| *a + 4);
assert_eq!(vect[0], 7);
- let vect = (vec!(3, 4)).map_::<uint, _>(|a| *a as uint + 4_usize);
+ let vect = (vec!(3, 4)).map_::<usize, _>(|a| *a as usize + 4_usize);
assert_eq!(vect[0], 7_usize);
let mut x = 0_usize;
10_usize.multi(|_n| x += 2_usize );
// pretty-expanded FIXME #23616
trait Deserializer {
- fn read_int(&self) -> int;
+ fn read_int(&self) -> isize;
}
trait Deserializable<D:Deserializer> {
fn deserialize(d: &D) -> Self;
}
-impl<D:Deserializer> Deserializable<D> for int {
- fn deserialize(d: &D) -> int {
+impl<D:Deserializer> Deserializable<D> for isize {
+ fn deserialize(d: &D) -> isize {
return d.read_int();
}
}
struct FromThinAir { dummy: () }
impl Deserializer for FromThinAir {
- fn read_int(&self) -> int { 22 }
+ fn read_int(&self) -> isize { 22 }
}
pub fn main() {
let d = FromThinAir { dummy: () };
- let i: int = Deserializable::deserialize(&d);
+ let i: isize = Deserializable::deserialize(&d);
assert_eq!(i, 22);
}
use static_methods_crate::read;
pub fn main() {
- let result: int = read("5".to_string());
+ let result: isize = read("5".to_string());
assert_eq!(result, 5);
assert_eq!(read::readMaybe("false".to_string()), Some(false));
assert_eq!(read::readMaybe("foo".to_string()), None::<bool>);
fn foo() -> Self;
}
- impl Foo for int {
- fn foo() -> int {
+ impl Foo for isize {
+ fn foo() -> isize {
3
}
}
- impl Foo for uint {
- fn foo() -> uint {
+ impl Foo for usize {
+ fn foo() -> usize {
5
}
}
}
pub fn main() {
- let x: int = a::Foo::foo();
- let y: uint = a::Foo::foo();
+ let x: isize = a::Foo::foo();
+ let y: usize = a::Foo::foo();
assert_eq!(x, 3);
assert_eq!(y, 5);
}
extern crate static_mut_xc;
-unsafe fn static_bound(_: &'static int) {}
+unsafe fn static_bound(_: &'static isize) {}
-fn static_bound_set(a: &'static mut int) {
+fn static_bound_set(a: &'static mut isize) {
*a = 3;
}
}
pub mod inner {
- pub static mut a: int = 4;
+ pub static mut a: isize = 4;
}
// pretty-expanded FIXME #23616
struct S {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
type S2 = S;
enum Foo {
Bar {
- a: int,
- b: int
+ a: isize,
+ b: isize
},
Baz {
c: f64,
enum Foo {
Bar {
- x: int,
- y: int
+ x: isize,
+ y: isize
},
Baz {
x: f64,
// pretty-expanded FIXME #23616
struct Foo {
- new: int,
+ new: isize,
}
pub fn main() {
// pretty-expanded FIXME #23616
-struct S { f0: String, f1: int }
+struct S { f0: String, f1: isize }
pub fn main() {
let s = "Hello, world!".to_string();
pub struct Partial<T> { x: T, y: T }
#[derive(PartialEq, Debug)]
-struct S { val: int }
-impl S { fn new(v: int) -> S { S { val: v } } }
+struct S { val: isize }
+impl S { fn new(v: isize) -> S { S { val: v } } }
impl Drop for S { fn drop(&mut self) { } }
pub fn f<T, F>((b1, b2): (T, T), mut f: F) -> Partial<T> where F: FnMut(T) -> T {
pub struct Partial<T> { x: T, y: T }
#[derive(PartialEq, Debug)]
-struct S { val: int }
-impl S { fn new(v: int) -> S { S { val: v } } }
+struct S { val: isize }
+impl S { fn new(v: isize) -> S { S { val: v } } }
impl Drop for S { fn drop(&mut self) { } }
pub type Two<T> = (Partial<T>, Partial<T>);
// except according to those terms.
struct Foo {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
pub fn main() {
c: 0xcccc_cccc_cccc_cccc,
d: 0xdddd_dddd_dddd_dddd };
let qq = rustrt::rust_dbg_abi_1(q);
- println!("a: {:x}", qq.a as uint);
- println!("b: {:x}", qq.b as uint);
- println!("c: {:x}", qq.c as uint);
- println!("d: {:x}", qq.d as uint);
+ println!("a: {:x}", qq.a as usize);
+ println!("b: {:x}", qq.b as usize);
+ println!("c: {:x}", qq.c as usize);
+ println!("d: {:x}", qq.d as usize);
assert_eq!(qq.a, q.c + 1);
assert_eq!(qq.b, q.d - 1);
assert_eq!(qq.c, q.a + 1);
c: 1.0987654321e-15_f64 };
let ff = rustrt::rust_dbg_abi_2(f);
println!("a: {}", ff.a as f64);
- println!("b: {}", ff.b as uint);
+ println!("b: {}", ff.b as usize);
println!("c: {}", ff.c as f64);
assert_eq!(ff.a, f.c + 1.0f64);
assert_eq!(ff.b, 0xff);
mod foo {
pub enum Foo {
- Bar { a: int }
+ Bar { a: isize }
}
}
impl PartialEq for foo {
fn eq(&self, other: &foo) -> bool {
- ((*self) as uint) == ((*other) as uint)
+ ((*self) as usize) == ((*other) as usize)
}
fn ne(&self, other: &foo) -> bool { !(*self).eq(other) }
}
//
// Big stack is needed for pretty printing, a little sad...
-static a: int =
+static a: isize =
(((((((((((((((((((((((((((((((((((((((((((((((((((
(((((((((((((((((((((((((((((((((((((((((((((((((((
(((((((((((((((((((((((((((((((((((((((((((((((((((
pub fn main() {
let f = 1_usize as *const libc::FILE;
- println!("{:?}", f as int);
- println!("{:?}", f as uint);
+ println!("{:?}", f as isize);
+ println!("{:?}", f as usize);
println!("{:?}", f as i8);
println!("{:?}", f as i16);
println!("{:?}", f as i32);
println!("{:?}", f as u32);
println!("{:?}", f as u64);
- println!("{:?}", 1 as int);
- println!("{:?}", 1 as uint);
+ println!("{:?}", 1 as isize);
+ println!("{:?}", 1 as usize);
println!("{:?}", 1 as *const libc::FILE);
println!("{:?}", 1 as i8);
println!("{:?}", 1 as i16);
println!("{:?}", 1 as f32);
println!("{:?}", 1 as f64);
- println!("{:?}", 1_usize as int);
- println!("{:?}", 1_usize as uint);
+ println!("{:?}", 1_usize as isize);
+ println!("{:?}", 1_usize as usize);
println!("{:?}", 1_usize as *const libc::FILE);
println!("{:?}", 1_usize as i8);
println!("{:?}", 1_usize as i16);
println!("{:?}", 1_usize as f32);
println!("{:?}", 1_usize as f64);
- println!("{:?}", 1i8 as int);
- println!("{:?}", 1i8 as uint);
+ println!("{:?}", 1i8 as isize);
+ println!("{:?}", 1i8 as usize);
println!("{:?}", 1i8 as *const libc::FILE);
println!("{:?}", 1i8 as i8);
println!("{:?}", 1i8 as i16);
println!("{:?}", 1i8 as f32);
println!("{:?}", 1i8 as f64);
- println!("{:?}", 1u8 as int);
- println!("{:?}", 1u8 as uint);
+ println!("{:?}", 1u8 as isize);
+ println!("{:?}", 1u8 as usize);
println!("{:?}", 1u8 as *const libc::FILE);
println!("{:?}", 1u8 as i8);
println!("{:?}", 1u8 as i16);
println!("{:?}", 1u8 as f32);
println!("{:?}", 1u8 as f64);
- println!("{:?}", 1i16 as int);
- println!("{:?}", 1i16 as uint);
+ println!("{:?}", 1i16 as isize);
+ println!("{:?}", 1i16 as usize);
println!("{:?}", 1i16 as *const libc::FILE);
println!("{:?}", 1i16 as i8);
println!("{:?}", 1i16 as i16);
println!("{:?}", 1i16 as f32);
println!("{:?}", 1i16 as f64);
- println!("{:?}", 1u16 as int);
- println!("{:?}", 1u16 as uint);
+ println!("{:?}", 1u16 as isize);
+ println!("{:?}", 1u16 as usize);
println!("{:?}", 1u16 as *const libc::FILE);
println!("{:?}", 1u16 as i8);
println!("{:?}", 1u16 as i16);
println!("{:?}", 1u16 as f32);
println!("{:?}", 1u16 as f64);
- println!("{:?}", 1i32 as int);
- println!("{:?}", 1i32 as uint);
+ println!("{:?}", 1i32 as isize);
+ println!("{:?}", 1i32 as usize);
println!("{:?}", 1i32 as *const libc::FILE);
println!("{:?}", 1i32 as i8);
println!("{:?}", 1i32 as i16);
println!("{:?}", 1i32 as f32);
println!("{:?}", 1i32 as f64);
- println!("{:?}", 1u32 as int);
- println!("{:?}", 1u32 as uint);
+ println!("{:?}", 1u32 as isize);
+ println!("{:?}", 1u32 as usize);
println!("{:?}", 1u32 as *const libc::FILE);
println!("{:?}", 1u32 as i8);
println!("{:?}", 1u32 as i16);
println!("{:?}", 1u32 as f32);
println!("{:?}", 1u32 as f64);
- println!("{:?}", 1i64 as int);
- println!("{:?}", 1i64 as uint);
+ println!("{:?}", 1i64 as isize);
+ println!("{:?}", 1i64 as usize);
println!("{:?}", 1i64 as *const libc::FILE);
println!("{:?}", 1i64 as i8);
println!("{:?}", 1i64 as i16);
println!("{:?}", 1i64 as f32);
println!("{:?}", 1i64 as f64);
- println!("{:?}", 1u64 as int);
- println!("{:?}", 1u64 as uint);
+ println!("{:?}", 1u64 as isize);
+ println!("{:?}", 1u64 as usize);
println!("{:?}", 1u64 as *const libc::FILE);
println!("{:?}", 1u64 as i8);
println!("{:?}", 1u64 as i16);
println!("{:?}", 1u64 as f32);
println!("{:?}", 1u64 as f64);
- println!("{:?}", 1u64 as int);
- println!("{:?}", 1u64 as uint);
+ println!("{:?}", 1u64 as isize);
+ println!("{:?}", 1u64 as usize);
println!("{:?}", 1u64 as *const libc::FILE);
println!("{:?}", 1u64 as i8);
println!("{:?}", 1u64 as i16);
println!("{:?}", 1u64 as f32);
println!("{:?}", 1u64 as f64);
- println!("{:?}", true as int);
- println!("{:?}", true as uint);
+ println!("{:?}", true as isize);
+ println!("{:?}", true as usize);
println!("{:?}", true as *const libc::FILE);
println!("{:?}", true as i8);
println!("{:?}", true as i16);
println!("{:?}", true as f32);
println!("{:?}", true as f64);
- println!("{:?}", 1f32 as int);
- println!("{:?}", 1f32 as uint);
+ println!("{:?}", 1f32 as isize);
+ println!("{:?}", 1f32 as usize);
println!("{:?}", 1f32 as i8);
println!("{:?}", 1f32 as i16);
println!("{:?}", 1f32 as i32);
println!("{:?}", 1f32 as f32);
println!("{:?}", 1f32 as f64);
- println!("{:?}", 1f64 as int);
- println!("{:?}", 1f64 as uint);
+ println!("{:?}", 1f64 as isize);
+ println!("{:?}", 1f64 as usize);
println!("{:?}", 1f64 as i8);
println!("{:?}", 1f64 as i16);
println!("{:?}", 1f64 as i32);
use std::mem::swap;
pub fn main() {
- let mut a: Vec<int> = vec!(0, 1, 2, 3, 4, 5, 6);
+ let mut a: Vec<isize> = vec!(0, 1, 2, 3, 4, 5, 6);
a.swap(2, 4);
assert_eq!(a[2], 4);
assert_eq!(a[4], 2);
}
pub enum TestFn {
- DynTestFn(int),
- DynBenchFn(int),
+ DynTestFn(isize),
+ DynBenchFn(isize),
}
pub struct TestDesc {
}
fn is_u64_aligned(u: &Tag<u64>) -> bool {
- let p: uint = unsafe { mem::transmute(u) };
+ let p: usize = unsafe { mem::transmute(u) };
let u64_align = std::mem::min_align_of::<u64>();
return (p & (u64_align - 1)) == 0;
}
Rec { chA:0, tA:Tag::VarA(a), chB:1, tB:Tag::VarB(b) }
}
-fn is_aligned<A>(amnt: uint, u: &A) -> bool {
- let p: uint = unsafe { mem::transmute(u) };
+fn is_aligned<A>(amnt: usize, u: &A) -> bool {
+ let p: usize = unsafe { mem::transmute(u) };
return (p & (amnt-1)) == 0;
}
-fn variant_data_is_aligned<A,B>(amnt: u
int, u: &Tag<A,B>) -> bool {
+fn variant_data_is_aligned<A,B>(amnt: u
size, u: &Tag<A,B>) -> bool {
match u {
&Tag::VarA(ref a) => is_aligned(amnt, a),
&Tag::VarB(ref b) => is_aligned(amnt, b)
}
fn is_u64_aligned(u: &Tag) -> bool {
- let p: uint = unsafe { mem::transmute(u) };
+ let p: usize = unsafe { mem::transmute(u) };
let u64_align = std::mem::min_align_of::<u64>();
return (p & (u64_align - 1)) == 0;
}
impl PartialEq for color {
fn eq(&self, other: &color) -> bool {
- ((*self) as uint) == ((*other) as uint)
+ ((*self) as usize) == ((*other) as usize)
}
fn ne(&self, other: &color) -> bool { !(*self).eq(other) }
}
test_color(orange, 4, "orange".to_string());
}
-fn test_color(color: color, val: int, name: String) {
+fn test_color(color: color, val: isize, name: String) {
//assert!(unsafe::transmute(color) == val);
- assert_eq!(color as int, val);
+ assert_eq!(color as isize, val);
assert!(get_color_alt(color) == name);
assert!(get_color_if(color) == name);
}
// pretty-expanded FIXME #23616
-enum colour { red(int, int), green, }
+enum colour { red(isize, isize), green, }
impl PartialEq for colour {
fn eq(&self, other: &colour) -> bool {
pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
-fn evenk(n: int, k: fn(bool) -> bool) -> bool {
+fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
println!("evenk");
println!("{}", n);
if n == 0 { return k(true); } else { return oddk(n - 1, k); }
}
-fn oddk(n: int, k: fn(bool) -> bool) -> bool {
+fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
println!("oddk");
println!("{}", n);
if n == 0 { return k(false); } else { return evenk(n - 1, k); }
pub fn main() { assert!((even(42))); assert!((odd(45))); }
-fn even(n: int) -> bool { if n == 0 { return true; } else { return odd(n - 1); } }
+fn even(n: isize) -> bool { if n == 0 { return true; } else { return odd(n - 1); } }
-fn odd(n: int) -> bool { if n == 0 { return false; } else { return even(n - 1); } }
+fn odd(n: isize) -> bool { if n == 0 { return false; } else { return even(n - 1); } }
pub fn main() { test05(); }
-fn test05_start(tx : &Sender<int>) {
+fn test05_start(tx : &Sender<isize>) {
tx.send(10).unwrap();
println!("sent 10");
tx.send(20).unwrap();
fn test05() {
let (tx, rx) = channel();
let _t = Thread::spawn(move|| { test05_start(&tx) });
- let mut value: int = rx.recv().unwrap();
+ let mut value: isize = rx.recv().unwrap();
println!("{}", value);
value = rx.recv().unwrap();
println!("{}", value);
use std::sync::mpsc::{channel, Sender};
use std::thread::Thread;
-fn start(tx: &Sender<Sender<int>>) {
+fn start(tx: &Sender<Sender<isize>>) {
let (tx2, _rx) = channel();
tx.send(tx2).unwrap();
}
pub fn main() { test00(); }
-fn start(_task_number: int) { println!("Started / Finished task."); }
+fn start(_task_number: isize) { println!("Started / Finished task."); }
fn test00() {
- let i: int = 0;
+ let i: isize = 0;
let mut result = Thread::scoped(move|| {
start(i)
});
use std::sync::mpsc::{channel, Sender};
use std::thread::Thread;
-fn start(tx: &Sender<int>, start: int, number_of_messages: int) {
- let mut i: int = 0;
+fn start(tx: &Sender<isize>, start: isize, number_of_messages: isize) {
+ let mut i: isize = 0;
while i< number_of_messages { tx.send(start + i).unwrap(); i += 1; }
}
pub fn main() {
let (tx, rx) = channel();
- // Spawn 10 tasks each sending us back one int.
+ // Spawn 10 tasks each sending us back one isize.
let mut i = 10;
while (i > 0) {
println!("{}", i);
println!("main thread exiting");
}
-fn child(x: int, tx: &Sender<int>) {
+fn child(x: isize, tx: &Sender<isize>) {
println!("{}", x);
tx.send(x).unwrap();
}
use std::sync::mpsc::{channel, Sender};
use std::thread::Thread;
-fn start(tx: &Sender<int>, i0: int) {
+fn start(tx: &Sender<isize>, i0: isize) {
let mut i = i0;
while i > 0 {
tx.send(0).unwrap();
// Tests of ports and channels on various types
fn test_rec() {
- struct R {val0: int, val1: u8, val2: char}
+ struct R {val0: isize, val1: u8, val2: char}
let (tx, rx) = channel();
let r0: R = R {val0: 0, val1: 1, val2: '2'};
fn test_vec() {
let (tx, rx) = channel();
- let v0: Vec<int> = vec!(0, 1, 2);
+ let v0: Vec<isize> = vec!(0, 1, 2);
tx.send(v0).unwrap();
let v1 = rx.recv().unwrap();
assert_eq!(v1[0], 0);
#[derive(Debug)]
enum t {
tag1,
- tag2(int),
- tag3(int, u8, char)
+ tag2(isize),
+ tag3(isize, u8, char)
}
impl cmp::PartialEq for t {
// Does the transmitted channel still work?
tx2.send(10).unwrap();
- let mut i: int;
+ let mut i: isize;
i = rx2.recv().unwrap();
assert_eq!(i, 10);
}
pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); }
-fn test00_start(ch: &Sender<int>, message: int, count: int) {
+fn test00_start(ch: &Sender<isize>, message: isize, count: isize) {
println!("Starting test00_start");
- let mut i: int = 0;
+ let mut i: isize = 0;
while i < count {
println!("Sending Message");
ch.send(message + 0).unwrap();
}
fn test00() {
- let number_of_tasks: int = 16;
- let number_of_messages: int = 4;
+ let number_of_tasks: isize = 16;
+ let number_of_messages: isize = 4;
println!("Creating tasks");
let (tx, rx) = channel();
- let mut i: int = 0;
+ let mut i: isize = 0;
// Create and spawn tasks...
let mut results = Vec::new();
pub fn main() { test00(); }
fn test00() {
- let mut r: int = 0;
- let mut sum: int = 0;
+ let mut r: isize = 0;
+ let mut sum: isize = 0;
let (tx, rx) = channel();
tx.send(1).unwrap();
tx.send(2).unwrap();
pub fn main() { test00(); }
fn test00() {
- let _r: int = 0;
- let mut sum: int = 0;
+ let _r: isize = 0;
+ let mut sum: isize = 0;
let (tx, rx) = channel();
- let number_of_messages: int = 1000;
- let mut i: int = 0;
+ let number_of_messages: isize = 1000;
+ let mut i: isize = 0;
while i < number_of_messages { tx.send(i + 0).unwrap(); i += 1; }
i = 0;
while i < number_of_messages { sum += rx.recv().unwrap(); i += 1; }
pub fn main() { test00(); }
fn test00() {
- let mut r: int = 0;
- let mut sum: int = 0;
+ let mut r: isize = 0;
+ let mut sum: isize = 0;
let (tx, rx) = channel();
let mut tx0 = tx.clone();
let mut tx1 = tx.clone();
let mut tx2 = tx.clone();
let mut tx3 = tx.clone();
- let number_of_messages: int = 1000;
- let mut i: int = 0;
+ let number_of_messages: isize = 1000;
+ let mut i: isize = 0;
while i < number_of_messages {
tx0.send(i + 0).unwrap();
tx1.send(i + 0).unwrap();
pub fn main() { test00(); }
-fn test00_start(c: &Sender<int>, start: int,
- number_of_messages: int) {
- let mut i: int = 0;
+fn test00_start(c: &Sender<isize>, start: isize,
+ number_of_messages: isize) {
+ let mut i: isize = 0;
while i < number_of_messages { c.send(start + i).unwrap(); i += 1; }
}
fn test00() {
- let mut r: int = 0;
- let mut sum: int = 0;
+ let mut r: isize = 0;
+ let mut sum: isize = 0;
let (tx, rx) = channel();
- let number_of_messages: int = 10;
+ let number_of_messages: isize = 10;
let tx2 = tx.clone();
let _t = Thread::spawn(move|| {
test00_start(&tx2, number_of_messages * 3, number_of_messages);
});
- let mut i: int = 0;
+ let mut i: isize = 0;
while i < number_of_messages {
r = rx.recv().unwrap();
sum += r;
pub fn main() { test00(); }
-fn test00_start(c: &Sender<int>, number_of_messages: int) {
- let mut i: int = 0;
+fn test00_start(c: &Sender<isize>, number_of_messages: isize) {
+ let mut i: isize = 0;
while i < number_of_messages { c.send(i + 0).unwrap(); i += 1; }
}
fn test00() {
- let r: int = 0;
- let mut sum: int = 0;
+ let r: isize = 0;
+ let mut sum: isize = 0;
let (tx, rx) = channel();
- let number_of_messages: int = 10;
+ let number_of_messages: isize = 10;
let result = Thread::scoped(move|| {
test00_start(&tx, number_of_messages);
});
- let mut i: int = 0;
+ let mut i: isize = 0;
while i < number_of_messages {
sum += rx.recv().unwrap();
println!("{}", r);
use std::sync::mpsc::channel;
pub fn main() {
- let (tx, rx) = channel::<uint>();
+ let (tx, rx) = channel::<usize>();
- let x: Box<int> = box 1;
- let x_in_parent = &(*x) as *const int as uint;
+ let x: Box<isize> = box 1;
+ let x_in_parent = &(*x) as *const isize as usize;
let _t = Thread::spawn(move || {
- let x_in_child = &(*x) as *const int as uint;
+ let x_in_child = &(*x) as *const isize as usize;
tx.send(x_in_child).unwrap();
});
use std::sync::mpsc::channel;
use std::thread::Thread;
-static N: uint = 8;
-static M: uint = 20;
+static N: usize = 8;
+static M: usize = 20;
fn main() {
test();
use std::thread;
-fn test_break() { loop { let _x: Box<int> = break; } }
+fn test_break() { loop { let _x: Box<isize> = break; } }
-fn test_cont() { let mut i = 0; while i < 1 { i += 1; let _x: Box<int> = continue; } }
+fn test_cont() { let mut i = 0; while i < 1 { i += 1; let _x: Box<isize> = continue; } }
-fn test_ret() { let _x: Box<int> = return; }
+fn test_ret() { let _x: Box<isize> = return; }
fn test_panic() {
- fn f() { let _x: Box<int> = panic!(); }
+ fn f() { let _x: Box<isize> = panic!(); }
thread::spawn(move|| f() ).join().err().unwrap();
}
fn test_panic_indirect() {
fn f() -> ! { panic!(); }
- fn g() { let _x: Box<int> = f(); }
+ fn g() { let _x: Box<isize> = f(); }
thread::spawn(move|| g() ).join().err().unwrap();
}
println!("main thread exiting");
}
-fn child(x: int) { println!("{}", x); }
+fn child(x: isize) { println!("{}", x); }
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns,)]
+#![feature(slice_patterns)]
fn f<T,>(_: T,) {}
struct Bar;
impl Bar {
- fn f(_: int,) {}
- fn g(self, _: int,) {}
+ fn f(_: isize,) {}
+ fn g(self, _: isize,) {}
fn h(self,) {}
}
enum Baz {
- Qux(int,),
+ Qux(isize,),
}
#[allow(unused,)]
pub fn main() {
- f::<int,>(0,);
+ f::<isize,>(0,);
let (_, _,) = (1, 1,);
let [_, _,] = [1, 1,];
let [_, _, .., _,] = [1, 1, 1, 1,];
let [_, _, _.., _,] = [1, 1, 1, 1,];
- let x: Foo<int,> = Foo::<int,>(1);
+ let x: Foo<isize,> = Foo::<isize,>(1);
Bar::f(0,);
Bar.g(0,);
fn foo<T: Eq + Ord>(&self);
}
-impl A for int {
+impl A for isize {
fn foo<T: Ord>(&self) {} // Ord implies Eq, so this is ok.
}
trait Pet {
fn name(&self, blk: Box<FnMut(&str)>);
- fn num_legs(&self) -> uint;
+ fn num_legs(&self) -> usize;
fn of_good_pedigree(&self) -> bool;
}
struct Catte {
- num_whiskers: uint,
+ num_whiskers: usize,
name: String,
}
struct Dogge {
- bark_decibels: uint,
- tricks_known: uint,
+ bark_decibels: usize,
+ tricks_known: usize,
name: String,
}
struct Goldfyshe {
- swim_speed: uint,
+ swim_speed: usize,
name: String,
}
impl Pet for Catte {
fn name(&self, mut blk: Box<FnMut(&str)>) { blk(&self.name) }
- fn num_legs(&self) -> uint { 4 }
+ fn num_legs(&self) -> usize { 4 }
fn of_good_pedigree(&self) -> bool { self.num_whiskers >= 4 }
}
impl Pet for Dogge {
fn name(&self, mut blk: Box<FnMut(&str)>) { blk(&self.name) }
- fn num_legs(&self) -> uint { 4 }
+ fn num_legs(&self) -> usize { 4 }
fn of_good_pedigree(&self) -> bool {
self.bark_decibels < 70 || self.tricks_known > 20
}
}
impl Pet for Goldfyshe {
fn name(&self, mut blk: Box<FnMut(&str)>) { blk(&self.name) }
- fn num_legs(&self) -> uint { 0 }
+ fn num_legs(&self) -> usize { 0 }
fn of_good_pedigree(&self) -> bool { self.swim_speed >= 500 }
}
// pretty-expanded FIXME #23616
trait connection {
- fn read(&self) -> int;
+ fn read(&self) -> isize;
}
trait connection_factory<C:connection> {
type my_connection_factory = ();
impl connection for () {
- fn read(&self) -> int { 43 }
+ fn read(&self) -> isize { 43 }
}
impl connection_factory<my_connection> for my_connection_factory {
#[derive(Copy)]
struct Struct {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
impl Trait<&'static str> for Struct {
#[derive(Copy)]
struct Struct {
- x: int,
- y: int,
+ x: isize,
+ y: isize,
}
impl Trait for Struct {
fn g(&self, x: T) -> T { x }
}
-impl A<int> for int { }
+impl A<isize> for isize { }
fn f<T, V: A<T>>(i: V, j: T) -> T {
i.g(j)
fn g<T>(&self, x: T, y: T) -> (T, T) { (x, y) }
}
-impl A for int { }
+impl A for isize { }
fn f<T, V: A>(i: V, j: T, k: T) -> (T, T) {
i.g(j, k)
// pretty-expanded FIXME #23616
trait A<T> {
- fn g(&self, x: uint) -> uint { x }
+ fn g(&self, x: usize) -> usize { x }
fn h(&self, x: T) { }
}
-impl<T> A<T> for int { }
+impl<T> A<T> for isize { }
-fn f<T, V: A<T>>(i: V, j: uint) -> uint {
+fn f<T, V: A<T>>(i: V, j: usize) -> usize {
i.g(j)
}
pub fn main () {
- assert_eq!(f::<f64, int>(0, 2), 2);
- assert_eq!(f::<uint, int>(0, 2), 2);
+ assert_eq!(f::<f64, isize>(0, 2), 2);
+ assert_eq!(f::<usize, isize>(0, 2), 2);
}
// pretty-expanded FIXME #23616
trait A {
- fn g(&self) -> int { 10 }
+ fn g(&self) -> isize { 10 }
}
-impl A for int { }
+impl A for isize { }
fn f<T:A>(i: T) {
assert_eq!(i.g(), 10);
// pretty-expanded FIXME #23616
-extern crate "trait_default_method_xc_aux" as aux;
-extern crate "trait_default_method_xc_aux_2" as aux2;
+extern crate trait_default_method_xc_aux as aux;
+extern crate trait_default_method_xc_aux_2 as aux2;
use aux::A;
use aux2::{a_struct, welp};
// pretty-expanded FIXME #23616
-extern crate "trait_default_method_xc_aux" as aux;
+extern crate trait_default_method_xc_aux as aux;
use aux::{A, TestEquality, Something};
use aux::B;
assert_eq!(i.g(), 10);
}
-fn welp<T>(i: int, _x: &T) -> int {
+fn welp<T>(i: isize, _x: &T) -> isize {
i.g()
}
mod stuff {
- pub struct thing { pub x: int }
+ pub struct thing { pub x: isize }
}
impl A for stuff::thing {
- fn f(&self) -> int { 10 }
+ fn f(&self) -> isize { 10 }
}
fn g<T, U, V: B<T>>(i: V, j: T, k: U) -> (T, U) {
assert_eq!(0.thing(3.14f64, 1), (3.14f64, 1));
assert_eq!(B::staticthing(&0, 3.14f64, 1), (3.14f64, 1));
- assert_eq!(B::<f64>::staticthing::<int>(&0, 3.14, 1), (3.14, 1));
+ assert_eq!(B::<f64>::staticthing::<isize>(&0, 3.14, 1), (3.14, 1));
assert_eq!(g(0, 3.14f64, 1), (3.14f64, 1));
assert_eq!(g(false, 3.14f64, 1), (3.14, 1));
trait to_str {
fn to_string_(&self) -> String;
}
-impl to_str for int {
+impl to_str for isize {
fn to_string_(&self) -> String { self.to_string() }
}
impl to_str for String {
pub fn main() {
assert_eq!(foo(vec!(1)), ["hi".to_string()]);
- assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), ["4".to_string(), "5".to_string()]);
+ assert_eq!(bar::<isize, Vec<isize> >(vec!(4, 5)), ["4".to_string(), "5".to_string()]);
assert_eq!(bar::<String, Vec<String> >(vec!("x".to_string(), "y".to_string())),
["x".to_string(), "y".to_string()]);
assert_eq!(bar::<(), Vec<()>>(vec!(())), ["()".to_string()]);
extern crate traitimpl;
use traitimpl::Bar;
-static mut COUNT: uint = 1;
+static mut COUNT: usize = 1;
trait T {
fn t(&self) {}
}
}
-impl T for int {}
+impl T for isize {}
struct Foo;
impl<'a> Bar<'a> for Foo {}
// pretty-expanded FIXME #23616
-extern crate "trait_inheritance_auto_xc_2_aux" as aux;
+extern crate trait_inheritance_auto_xc_2_aux as aux;
// aux defines impls of Foo, Bar and Baz for A
use aux::{Foo, Bar, Baz, A};
// pretty-expanded FIXME #23616
-extern crate "trait_inheritance_auto_xc_aux" as aux;
+extern crate trait_inheritance_auto_xc_aux as aux;
use aux::{Foo, Bar, Baz, Quux};
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
-impl Baz for A { fn h(&self) -> int { 30 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
+impl Baz for A { fn h(&self) -> isize { 30 } }
fn f<T:Quux>(a: &T) {
assert_eq!(a.f(), 10);
impl<T:Foo + Bar + Baz> Quux for T { }
-trait Foo { fn f(&self) -> int; }
-trait Bar { fn g(&self) -> int; }
-trait Baz { fn h(&self) -> int; }
+trait Foo { fn f(&self) -> isize; }
+trait Bar { fn g(&self) -> isize; }
+trait Baz { fn h(&self) -> isize; }
trait Quux: Foo + Bar + Baz { }
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
-impl Baz for A { fn h(&self) -> int { 30 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
+impl Baz for A { fn h(&self) -> isize { 30 } }
fn f<T:Quux>(a: &T) {
assert_eq!(a.f(), 10);
// pretty-expanded FIXME #23616
-trait Foo { fn f(&self) -> int; }
-trait Bar : Foo { fn g(&self) -> int; }
+trait Foo { fn f(&self) -> isize; }
+trait Bar : Foo { fn g(&self) -> isize; }
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
// Call a function on Foo, given a T: Bar
-fn gg<T:Bar>(a: &T) -> int {
+fn gg<T:Bar>(a: &T) -> isize {
a.f()
}
// pretty-expanded FIXME #23616
-trait Foo { fn f(&self) -> int; }
-trait Bar : Foo { fn g(&self) -> int; }
-trait Baz : Bar { fn h(&self) -> int; }
+trait Foo { fn f(&self) -> isize; }
+trait Bar : Foo { fn g(&self) -> isize; }
+trait Baz : Bar { fn h(&self) -> isize; }
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
-impl Baz for A { fn h(&self) -> int { 30 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
+impl Baz for A { fn h(&self) -> isize { 30 } }
// Call a function on Foo, given a T: Baz,
// which is inherited via Bar
-fn gg<T:Baz>(a: &T) -> int {
+fn gg<T:Baz>(a: &T) -> isize {
a.f()
}
// pretty-expanded FIXME #23616
trait Foo {
- fn f(&self) -> int;
+ fn f(&self) -> isize;
}
trait Bar : Foo {
- fn g(&self) -> int;
+ fn g(&self) -> isize;
}
struct A {
- x: int
+ x: isize
}
impl Foo for A {
- fn f(&self) -> int { 10 }
+ fn f(&self) -> isize { 10 }
}
impl Bar for A {
- fn g(&self) -> int { 20 }
+ fn g(&self) -> isize { 20 }
}
pub fn main() {
// pretty-expanded FIXME #23616
trait Foo {
- fn f(&self) -> int;
+ fn f(&self) -> isize;
}
trait Bar : Foo {
- fn g(&self) -> int;
+ fn g(&self) -> isize;
}
struct A {
- x: int
+ x: isize
}
impl Foo for A {
- fn f(&self) -> int { 10 }
+ fn f(&self) -> isize { 10 }
}
impl Bar for A {
- fn g(&self) -> int { 20 }
+ fn g(&self) -> isize { 20 }
}
pub fn main() {
// pretty-expanded FIXME #23616
-extern crate "trait_inheritance_cross_trait_call_xc_aux" as aux;
+extern crate trait_inheritance_cross_trait_call_xc_aux as aux;
use aux::Foo;
trait Bar : Foo {
- fn g(&self) -> int;
+ fn g(&self) -> isize;
}
impl Bar for aux::A {
- fn g(&self) -> int { self.f() }
+ fn g(&self) -> isize { self.f() }
}
pub fn main() {
// pretty-expanded FIXME #23616
-trait Foo { fn f(&self) -> int; }
-trait Bar : Foo { fn g(&self) -> int; }
+trait Foo { fn f(&self) -> isize; }
+trait Bar : Foo { fn g(&self) -> isize; }
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
impl Bar for A {
// Testing that this impl can call the impl of Foo
- fn g(&self) -> int { self.f() }
+ fn g(&self) -> isize { self.f() }
}
pub fn main() {
// pretty-expanded FIXME #23616
-trait A { fn a(&self) -> int; }
-trait B: A { fn b(&self) -> int; }
-trait C: A { fn c(&self) -> int; }
-trait D: B + C { fn d(&self) -> int; }
+trait A { fn a(&self) -> isize; }
+trait B: A { fn b(&self) -> isize; }
+trait C: A { fn c(&self) -> isize; }
+trait D: B + C { fn d(&self) -> isize; }
struct S { bogus: () }
-impl A for S { fn a(&self) -> int { 10 } }
-impl B for S { fn b(&self) -> int { 20 } }
-impl C for S { fn c(&self) -> int { 30 } }
-impl D for S { fn d(&self) -> int { 40 } }
+impl A for S { fn a(&self) -> isize { 10 } }
+impl B for S { fn b(&self) -> isize { 20 } }
+impl C for S { fn c(&self) -> isize { 30 } }
+impl D for S { fn d(&self) -> isize { 40 } }
fn f<T:D>(x: &T) {
assert_eq!(x.a(), 10);
// pretty-expanded FIXME #23616
-trait A { fn a(&self) -> int; }
-trait B: A { fn b(&self) -> int; }
-trait C: A { fn c(&self) -> int; }
+trait A { fn a(&self) -> isize; }
+trait B: A { fn b(&self) -> isize; }
+trait C: A { fn c(&self) -> isize; }
struct S { bogus: () }
-impl A for S { fn a(&self) -> int { 10 } }
-impl B for S { fn b(&self) -> int { 20 } }
-impl C for S { fn c(&self) -> int { 30 } }
+impl A for S { fn a(&self) -> isize { 10 } }
+impl B for S { fn b(&self) -> isize { 20 } }
+impl C for S { fn c(&self) -> isize { 30 } }
// Both B and C inherit from A
fn f<T:B + C>(x: &T) {
// pretty-expanded FIXME #23616
-trait A { fn a(&self) -> int; }
-trait B: A { fn b(&self) -> int; }
-trait C: A { fn c(&self) -> int; }
+trait A { fn a(&self) -> isize; }
+trait B: A { fn b(&self) -> isize; }
+trait C: A { fn c(&self) -> isize; }
struct S { bogus: () }
-impl A for S { fn a(&self) -> int { 10 } }
-impl B for S { fn b(&self) -> int { 20 } }
-impl C for S { fn c(&self) -> int { 30 } }
+impl A for S { fn a(&self) -> isize { 10 } }
+impl B for S { fn b(&self) -> isize { 20 } }
+impl C for S { fn c(&self) -> isize { 30 } }
// Multiple type params, multiple levels of inheritance
fn f<X:A,Y:B,Z:C>(x: &X, y: &Y, z: &Z) {
use std::num::NumCast;
pub trait Num {
- fn from_int(i: int) -> Self;
+ fn from_int(i: isize) -> Self;
fn gt(&self, other: &Self) -> bool;
}
impl TypeExt for u16 {}
impl TypeExt for u32 {}
impl TypeExt for u64 {}
-impl TypeExt for uint {}
+impl TypeExt for usize {}
impl TypeExt for i8 {}
impl TypeExt for i16 {}
impl TypeExt for i32 {}
impl TypeExt for i64 {}
-impl TypeExt for int {}
+impl TypeExt for isize {}
impl TypeExt for f32 {}
impl TypeExt for f64 {}
impl NumExt for u16 {}
impl NumExt for u32 {}
impl NumExt for u64 {}
-impl NumExt for uint {}
+impl NumExt for usize {}
impl NumExt for i8 {}
impl NumExt for i16 {}
impl NumExt for i32 {}
impl NumExt for i64 {}
-impl NumExt for int {}
+impl NumExt for isize {}
impl NumExt for f32 {}
impl NumExt for f64 {}
impl UnSignedExt for u16 {}
impl UnSignedExt for u32 {}
impl UnSignedExt for u64 {}
-impl UnSignedExt for uint {}
+impl UnSignedExt for usize {}
pub trait SignedExt: NumExt {}
impl SignedExt for i16 {}
impl SignedExt for i32 {}
impl SignedExt for i64 {}
-impl SignedExt for int {}
+impl SignedExt for isize {}
impl SignedExt for f32 {}
impl SignedExt for f64 {}
impl IntegerExt for u16 {}
impl IntegerExt for u32 {}
impl IntegerExt for u64 {}
-impl IntegerExt for uint {}
+impl IntegerExt for usize {}
impl IntegerExt for i8 {}
impl IntegerExt for i16 {}
impl IntegerExt for i32 {}
impl IntegerExt for i64 {}
-impl IntegerExt for int {}
+impl IntegerExt for isize {}
pub trait FloatExt: NumExt {}
pub trait NumExt: PartialEq + NumCast {}
impl NumExt for f32 {}
-impl NumExt for int {}
+impl NumExt for isize {}
fn num_eq_one<T:NumExt>() -> T {
NumCast::from(1).unwrap()
}
pub fn main() {
- num_eq_one::<int>(); // you need to actually use the function to trigger the ICE
+ num_eq_one::<isize>(); // you need to actually use the function to trigger the ICE
}
trait MyNum : PartialEq { }
#[derive(Debug)]
-struct MyInt { val: int }
+struct MyInt { val: isize }
impl PartialEq for MyInt {
fn eq(&self, other: &MyInt) -> bool { self.val == other.val }
return x == y;
}
-fn mi(v: int) -> MyInt { MyInt { val: v } }
+fn mi(v: isize) -> MyInt { MyInt { val: v } }
pub fn main() {
let (x, y, z) = (mi(3), mi(5), mi(3));
return (x.clone() + y.clone(), x.clone() - y.clone(), x * y);
}
-fn mi(v: int) -> MyInt { MyInt { val: v } }
+fn mi(v: isize) -> MyInt { MyInt { val: v } }
pub fn main() {
let (x, y) = (mi(3), mi(5));
trait MyNum : Add<Output=Self> + Sub<Output=Self> + Mul<Output=Self> + PartialEq + Clone { }
#[derive(Clone, Debug)]
-struct MyInt { val: int }
+struct MyInt { val: isize }
impl Add for MyInt {
type Output = MyInt;
return (x.clone() + y.clone(), x.clone() - y.clone(), x * y);
}
-fn mi(v: int) -> MyInt { MyInt { val: v } }
+fn mi(v: isize) -> MyInt { MyInt { val: v } }
pub fn main() {
let (x, y) = (mi(3), mi(5));
}
struct S {
- x: int
+ x: isize
}
impl Foo<S> for S {
// pretty-expanded FIXME #23616
-trait Foo { fn f(&self) -> int; }
-trait Bar : Foo { fn g(&self) -> int; }
+trait Foo { fn f(&self) -> isize; }
+trait Bar : Foo { fn g(&self) -> isize; }
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
-fn ff<T:Foo>(a: &T) -> int {
+fn ff<T:Foo>(a: &T) -> isize {
a.f()
}
-fn gg<T:Bar>(a: &T) -> int {
+fn gg<T:Bar>(a: &T) -> isize {
a.g()
}
// pretty-expanded FIXME #23616
pub trait MyNum {
- fn from_int(int) -> Self;
+ fn from_int(isize) -> Self;
}
pub trait NumExt: MyNum { }
-struct S { v: int }
+struct S { v: isize }
impl MyNum for S {
- fn from_int(i: int) -> S {
+ fn from_int(i: isize) -> S {
S {
v: i
}
pub trait MyEq : ::std::marker::MarkerTrait { }
pub trait MyNum : ::std::marker::MarkerTrait {
- fn from_int(int) -> Self;
+ fn from_int(isize) -> Self;
}
pub trait NumExt: MyEq + MyNum { }
-struct S { v: int }
+struct S { v: isize }
impl MyEq for S { }
impl MyNum for S {
- fn from_int(i: int) -> S {
+ fn from_int(i: isize) -> S {
S {
v: i
}
trait MyNum : Add<Self,Self> { }
-struct MyInt { val: int }
+struct MyInt { val: isize }
impl Add<MyInt, MyInt> for MyInt {
fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) }
return x.add(&y);
}
-fn mi(v: int) -> MyInt { MyInt { val: v } }
+fn mi(v: isize) -> MyInt { MyInt { val: v } }
pub fn main() {
let (x, y) = (mi(3), mi(5));
trait MyNum : Add<Self,Self> { }
-struct MyInt { val: int }
+struct MyInt { val: isize }
impl Panda<MyInt> for MyInt {
fn chomp(&self, bamboo: &MyInt) -> MyInt {
return x.add(&y).chomp(&y);
}
-fn mi(v: int) -> MyInt { MyInt { val: v } }
+fn mi(v: isize) -> MyInt { MyInt { val: v } }
pub fn main() {
let (x, y) = (mi(3), mi(5));
// pretty-expanded FIXME #23616
mod traits {
- pub trait Foo { fn f(&self) -> int; }
+ pub trait Foo { fn f(&self) -> isize; }
- impl Foo for int { fn f(&self) -> int { 10 } }
+ impl Foo for isize { fn f(&self) -> isize { 10 } }
}
trait Quux: traits::Foo { }
// pretty-expanded FIXME #23616
-trait Foo { fn f(&self) -> int; }
-trait Bar { fn g(&self) -> int; }
-trait Baz { fn h(&self) -> int; }
+trait Foo { fn f(&self) -> isize; }
+trait Bar { fn g(&self) -> isize; }
+trait Baz { fn h(&self) -> isize; }
trait Quux: Foo + Bar + Baz { }
-struct A { x: int }
+struct A { x: isize }
-impl Foo for A { fn f(&self) -> int { 10 } }
-impl Bar for A { fn g(&self) -> int { 20 } }
-impl Baz for A { fn h(&self) -> int { 30 } }
+impl Foo for A { fn f(&self) -> isize { 10 } }
+impl Bar for A { fn g(&self) -> isize { 20 } }
+impl Baz for A { fn h(&self) -> isize { 30 } }
impl Quux for A {}
fn f<T:Quux + Foo + Bar + Baz>(a: &T) {
enum Type<T> { Constant(T) }
trait Trait<K,V> {
- fn method(&self,Type<(K,V)>) -> int;
+ fn method(&self,Type<(K,V)>) -> isize;
}
impl<V> Trait<u8,V> for () {
- fn method(&self, _x: Type<(u8,V)>) -> int { 0 }
+ fn method(&self, _x: Type<(u8,V)>) -> isize { 0 }
}
pub fn main() {
// except according to those terms.
trait Foo {
- fn f(&self) -> int;
+ fn f(&self) -> isize;
}
struct A {
- x: int
+ x: isize
}
impl Foo for A {
- fn f(&self) -> int {
+ fn f(&self) -> isize {
println!("Today's number is {}", self.x);
return self.x;
}
use lib::Foo;
-struct Bar { x: int }
+struct Bar { x: isize }
unsafe impl Foo for Bar {
- fn foo(&self) -> int { self.x }
+ fn foo(&self) -> isize { self.x }
}
-fn take_foo<F:Foo>(f: &F) -> int { f.foo() }
+fn take_foo<F:Foo>(f: &F) -> isize { f.foo() }
fn main() {
- let x: int = 22;
+ let x: isize = 22;
assert_eq!(22, take_foo(&x));
let x: Bar = Bar { x: 23 };
// pretty-expanded FIXME #23616
unsafe trait Foo {
- fn foo(&self) -> int;
+ fn foo(&self) -> isize;
}
-unsafe impl Foo for int {
- fn foo(&self) -> int { *self }
+unsafe impl Foo for isize {
+ fn foo(&self) -> isize { *self }
}
-fn take_foo<F:Foo>(f: &F) -> int { f.foo() }
+fn take_foo<F:Foo>(f: &F) -> isize { f.foo() }
fn main() {
- let x: int = 22;
+ let x: isize = 22;
assert_eq!(22, take_foo(&x));
}
fn to_string_(&self) -> String;
}
-impl to_str for int {
+impl to_str for isize {
fn to_string_(&self) -> String { self.to_string() }
}
}
-impl Getter<int> for int {
- fn do_get(&self) -> int { *self }
+impl Getter<isize> for isize {
+ fn do_get(&self) -> isize { *self }
}
impl<T: Clone> Getter<T> for Option<T> {
///////////////////////////////////////////////////////////////////////////
struct SomeGoableThing {
- counter: Rc<Cell<int>>
+ counter: Rc<Cell<isize>>
}
impl Go for SomeGoableThing {
- fn go(&self, arg: int) {
+ fn go(&self, arg: isize) {
self.counter.set(self.counter.get() + arg);
}
}
///////////////////////////////////////////////////////////////////////////
struct SomeGoOnceableThing {
- counter: Rc<Cell<int>>
+ counter: Rc<Cell<isize>>
}
impl GoOnce for SomeGoOnceableThing {
- fn go_once(self, arg: int) {
+ fn go_once(self, arg: isize) {
self.counter.set(self.counter.get() + arg);
}
}
#![allow(unused_variable)]
trait Foo {
- fn foo(&self, mut v: int) { v = 1; }
+ fn foo(&self, mut v: isize) { v = 1; }
}
pub fn main() {}
fn purr(&self) -> bool { true }
}
-impl Cat for int {
+impl Cat for isize {
fn meow(&self) -> bool {
self.scratch()
}
fn purr(&self) -> bool { true }
}
-impl Cat for int {
+impl Cat for isize {
fn meow(&self) -> bool {
self.scratch()
}
}
}
-fn test<T,U>(_: T, _: U, t_size: uint, u_size: uint)
+fn test<T,U>(_: T, _: U, t_size: usize, u_size: usize)
where T : Convert<U>
{
assert_eq!(mem::size_of::<T>(), t_size);
pub fn main() {
unsafe {
- ::std::mem::transmute::<[int; 1],int>([1])
+ ::std::mem::transmute::<[isize; 1],isize>([1])
};
}
// pretty-expanded FIXME #23616
-type point = (int, int);
+type point = (isize, isize);
-fn f(p: point, x: int, y: int) {
+fn f(p: point, x: isize, y: isize) {
let (a, b) = p;
assert_eq!(a, x);
assert_eq!(b, y);
// pretty-expanded FIXME #23616
-struct Foo<'a>(&'a [int]);
+struct Foo<'a>(&'a [isize]);
fn main() {
- let x: &[int] = &[1, 2, 3];
+ let x: &[isize] = &[1, 2, 3];
let y = (x,);
assert_eq!(y.0, x);
- let x: &[int] = &[1, 2, 3];
+ let x: &[isize] = &[1, 2, 3];
let y = Foo(x);
assert_eq!(y.0, x);
}
// pretty-expanded FIXME #23616
-struct Point(int, int);
+struct Point(isize, isize);
fn main() {
let mut x = Point(3, 2);
// except according to those terms.
#[derive(Debug)]
-struct Foo(int, int);
+struct Foo(isize, isize);
pub fn main() {
let x = Foo(1, 2);
// except according to those terms.
#[derive(PartialEq, Debug)]
-struct Foo(int);
+struct Foo(isize);
#[derive(PartialEq, Debug)]
-struct Bar(int, int);
+struct Bar(isize, isize);
pub fn main() {
- let f: fn(int) -> Foo = Foo;
- let g: fn(int, int) -> Bar = Bar;
+ let f: fn(isize) -> Foo = Foo;
+ let g: fn(isize, isize) -> Bar = Bar;
assert_eq!(f(42), Foo(42));
assert_eq!(g(4, 7), Bar(4, 7));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct Foo(int, int);
+struct Foo(isize, isize);
pub fn main() {
let x = Foo(1, 2);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-struct Foo(int, int);
+struct Foo(isize, isize);
pub fn main() {
let x = Foo(1, 2);
// pretty-expanded FIXME #23616
-struct Foo(int, int, int);
+struct Foo(isize, isize, isize);
pub fn main() {
}
pub fn main() {
unsafe {
- assert_eq!(type_name::<int>(), "isize");
- assert_eq!(type_name::<Foo<uint>>(), "Foo<usize>");
+ assert_eq!(type_name::<isize>(), "isize");
+ assert_eq!(type_name::<Foo<usize>>(), "Foo<usize>");
}
}
#![feature(unboxed_closures, core)]
-use std::any::TypeId;
+use std::any::{Any, TypeId};
fn main() {
// Bare fns
{
- let a = TypeId::of::<fn(&'static int, &'static int)>();
- let b = TypeId::of::<for<'a> fn(&'static int, &'a int)>();
- let c = TypeId::of::<for<'a, 'b> fn(&'a int, &'b int)>();
- let d = TypeId::of::<for<'a, 'b> fn(&'b int, &'a int)>();
+ let a = TypeId::of::<fn(&'static isize, &'static isize)>();
+ let b = TypeId::of::<for<'a> fn(&'static isize, &'a isize)>();
+ let c = TypeId::of::<for<'a, 'b> fn(&'a isize, &'b isize)>();
+ let d = TypeId::of::<for<'a, 'b> fn(&'b isize, &'a isize)>();
assert!(a != b);
assert!(a != c);
assert!(a != d);
assert_eq!(c, d);
// Make sure De Bruijn indices are handled correctly
- let e = TypeId::of::<for<'a> fn(fn(&'a int) -> &'a int)>();
- let f = TypeId::of::<fn(for<'a> fn(&'a int) -> &'a int)>();
+ let e = TypeId::of::<for<'a> fn(fn(&'a isize) -> &'a isize)>();
+ let f = TypeId::of::<fn(for<'a> fn(&'a isize) -> &'a isize)>();
assert!(e != f);
}
// Boxed unboxed closures
{
- let a = TypeId::of::<Box<Fn(&'static int, &'static int)>>();
- let b = TypeId::of::<Box<for<'a> Fn(&'static int, &'a int)>>();
- let c = TypeId::of::<Box<for<'a, 'b> Fn(&'a int, &'b int)>>();
- let d = TypeId::of::<Box<for<'a, 'b> Fn(&'b int, &'a int)>>();
+ let a = TypeId::of::<Box<Fn(&'static isize, &'static isize)>>();
+ let b = TypeId::of::<Box<for<'a> Fn(&'static isize, &'a isize)>>();
+ let c = TypeId::of::<Box<for<'a, 'b> Fn(&'a isize, &'b isize)>>();
+ let d = TypeId::of::<Box<for<'a, 'b> Fn(&'b isize, &'a isize)>>();
assert!(a != b);
assert!(a != c);
assert!(a != d);
assert_eq!(c, d);
// Make sure De Bruijn indices are handled correctly
- let e = TypeId::of::<Box<for<'a> Fn(Box<Fn(&'a int) -> &'a int>)>>();
- let f = TypeId::of::<Box<Fn(Box<for<'a> Fn(&'a int) -> &'a int>)>>();
+ let e = TypeId::of::<Box<for<'a> Fn(Box<Fn(&'a isize) -> &'a isize>)>>();
+ let f = TypeId::of::<Box<Fn(Box<for<'a> Fn(&'a isize) -> &'a isize>)>>();
assert!(e != f);
}
// Raw unboxed closures
// Note that every unboxed closure has its own anonymous type,
// so no two IDs should equal each other, even when compatible
{
- let a = id(|_: &int, _: &int| {});
- let b = id(|_: &int, _: &int| {});
+ let a = id(|_: &isize, _: &isize| {});
+ let b = id(|_: &isize, _: &isize| {});
assert!(a != b);
}
- fn id<T:'static>(_: T) -> TypeId {
+ fn id<T:Any>(_: T) -> TypeId {
TypeId::of::<T>()
}
}
mod a {
pub mod b {
- pub type t = int;
+ pub type t = isize;
pub fn foo() { let _x: t = 10; }
}
// pretty-expanded FIXME #23616
-struct A { a: int }
+struct A { a: isize }
-fn a(a: A) -> int { return a.a; }
+fn a(a: A) -> isize { return a.a; }
pub fn main() { let x: A = A {a: 1}; assert!((a(x) == 1)); }
fn u_foo<T:Send>(_unique: T) { }
struct r {
- i: int,
+ i: isize,
}
impl Drop for r {
fn drop(&mut self) {}
}
-fn r(i:int) -> r {
+fn r(i:isize) -> r {
r {
i: i
}
struct S<T> {
a: T,
- b: uint,
+ b: usize,
}
-fn range_<F>(lo: uint, hi: uint, mut it: F) where F: FnMut(uint) {
+fn range_<F>(lo: usize, hi: usize, mut it: F) where F: FnMut(usize) {
let mut lo_ = lo;
while lo_ < hi { it(lo_); lo_ += 1; }
}
-fn create_index<T>(_index: Vec<S<T>> , _hash_fn: extern fn(T) -> uint) {
+fn create_index<T>(_index: Vec<S<T>> , _hash_fn: extern fn(T) -> usize) {
range_(0, 256, |_i| {
let _bucket: Vec<T> = Vec::new();
})
// pretty-expanded FIXME #23616
-fn f(a: *const int) -> *const int { return a; }
+fn f(a: *const isize) -> *const isize { return a; }
-fn g(a: *const int) -> *const int { let b = f(a); return b; }
+fn g(a: *const isize) -> *const isize { let b = f(a); return b; }
pub fn main() { return; }
struct u {a: u8, b: i8, c: u8}
struct v {a: u8, b: i8, c: v2, d: u32}
struct v2 {u: char, v: u8}
-struct w {a: int, b: ()}
-struct x {a: int, b: (), c: ()}
-struct y {x: int}
+struct w {a: isize, b: ()}
+struct x {a: isize, b: (), c: ()}
+struct y {x: isize}
enum e1 {
a(u8, u32), b(u32), c
}
pub fn main() {
- assert_eq!(size_of::<u8>(), 1 as uint);
- assert_eq!(size_of::<u32>(), 4 as uint);
- assert_eq!(size_of::<char>(), 4 as uint);
- assert_eq!(size_of::<i8>(), 1 as uint);
- assert_eq!(size_of::<i32>(), 4 as uint);
- assert_eq!(size_of::<t>(), 2 as uint);
- assert_eq!(size_of::<u>(), 3 as uint);
+ assert_eq!(size_of::<u8>(), 1 as usize);
+ assert_eq!(size_of::<u32>(), 4 as usize);
+ assert_eq!(size_of::<char>(), 4 as usize);
+ assert_eq!(size_of::<i8>(), 1 as usize);
+ assert_eq!(size_of::<i32>(), 4 as usize);
+ assert_eq!(size_of::<t>(), 2 as usize);
+ assert_eq!(size_of::<u>(), 3 as usize);
// Alignment causes padding before the char and the u32.
assert!(size_of::<v>() ==
- 16 as uint);
- assert_eq!(size_of::<int>(), size_of::<uint>());
- assert_eq!(size_of::<w>(), size_of::<int>());
- assert_eq!(size_of::<x>(), size_of::<int>());
- assert_eq!(size_of::<int>(), size_of::<y>());
+ 16 as usize);
+ assert_eq!(size_of::<isize>(), size_of::<usize>());
+ assert_eq!(size_of::<w>(), size_of::<isize>());
+ assert_eq!(size_of::<x>(), size_of::<isize>());
+ assert_eq!(size_of::<isize>(), size_of::<y>());
// Make sure enum types are the appropriate size, mostly
// around ensuring alignment is handled properly
- assert_eq!(size_of::<e1>(), 8 as uint);
- assert_eq!(size_of::<e2>(), 8 as uint);
- assert_eq!(size_of::<e3>(), 4 as uint);
+ assert_eq!(size_of::<e1>(), 8 as usize);
+ assert_eq!(size_of::<e2>(), 8 as usize);
+ assert_eq!(size_of::<e3>(), 4 as usize);
}
// pretty-expanded FIXME #23616
enum T {
- A(int),
+ A(isize),
B(f64)
}
#![feature(hash, core)]
-extern crate "typeid-intrinsic" as other1;
-extern crate "typeid-intrinsic2" as other2;
+extern crate typeid_intrinsic as other1;
+extern crate typeid_intrinsic2 as other2;
use std::hash::{self, SipHasher};
use std::any::TypeId;
assert_eq!(other1::id_G(), other2::id_G());
assert_eq!(other1::id_H(), other2::id_H());
- assert_eq!(TypeId::of::<int>(), other2::foo::<int>());
- assert_eq!(TypeId::of::<int>(), other1::foo::<int>());
- assert_eq!(other2::foo::<int>(), other1::foo::<int>());
+ assert_eq!(TypeId::of::<isize>(), other2::foo::<isize>());
+ assert_eq!(TypeId::of::<isize>(), other1::foo::<isize>());
+ assert_eq!(other2::foo::<isize>(), other1::foo::<isize>());
assert_eq!(TypeId::of::<A>(), other2::foo::<A>());
assert_eq!(TypeId::of::<A>(), other1::foo::<A>());
assert_eq!(other2::foo::<A>(), other1::foo::<A>());
}
// sanity test of TypeId
- let (a, b, c) = (TypeId::of::<uint>(), TypeId::of::<&'static str>(),
+ let (a, b, c) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
TypeId::of::<Test>());
- let (d, e, f) = (TypeId::of::<uint>(), TypeId::of::<&'static str>(),
+ let (d, e, f) = (TypeId::of::<usize>(), TypeId::of::<&'static str>(),
TypeId::of::<Test>());
assert!(a != b);
assert_eq!(c, f);
// check it has a hash
- let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>());
+ let (a, b) = (TypeId::of::<usize>(), TypeId::of::<usize>());
assert_eq!(hash::hash::<TypeId, SipHasher>(&a),
hash::hash::<TypeId, SipHasher>(&b));
#[derive(Copy)]
struct Foo {
- f: int,
+ f: isize,
}
impl Foo {
- fn foo(self: Foo, x: int) -> int {
+ fn foo(self: Foo, x: isize) -> isize {
self.f + x
}
- fn bar(self: &Foo, x: int) -> int {
+ fn bar(self: &Foo, x: isize) -> isize {
self.f + x
}
- fn baz(self: Box<Foo>, x: int) -> int {
+ fn baz(self: Box<Foo>, x: isize) -> isize {
self.f + x
}
}
}
impl<T> Bar<T> {
- fn foo(self: Bar<T>, x: int) -> int {
+ fn foo(self: Bar<T>, x: isize) -> isize {
x
}
- fn bar<'a>(self: &'a Bar<T>, x: int) -> int {
+ fn bar<'a>(self: &'a Bar<T>, x: isize) -> isize {
x
}
- fn baz(self: Bar<T>, x: int) -> int {
+ fn baz(self: Bar<T>, x: isize) -> isize {
x
}
}
f: 1,
};
println!("{} {} {}", bar.foo(2), bar.bar(2), bar.baz(2));
- let bar: Box<Bar<int>> = bar;
+ let bar: Box<Bar<isize>> = bar;
println!("{} {} {}", bar.foo(2), bar.bar(2), bar.baz(2));
}
// pretty-expanded FIXME #23616
-pub fn main() { let _x: uint = 10 as uint; }
+pub fn main() { let _x: usize = 10 as usize; }
println!("{}", d_neg);
let e = 1;
- let e_neg: int = -e;
+ let e_neg: isize = -e;
println!("{}", e_neg);
// intentional overflows
println!("{}", i_neg);
let j = 1;
- let j_neg: uint = -j;
+ let j_neg: usize = -j;
println!("{}", j_neg);
}
#![feature(lang_items, unboxed_closures)]
-fn a<F:Fn(int, int) -> int>(f: F) -> int {
+fn a<F:Fn(isize, isize) -> isize>(f: F) -> isize {
f(1, 2)
}
-fn b<F:FnMut(int, int) -> int>(mut f: F) -> int {
+fn b<F:FnMut(isize, isize) -> isize>(mut f: F) -> isize {
f(3, 4)
}
-fn c<F:FnOnce(int, int) -> int>(f: F) -> int {
+fn c<F:FnOnce(isize, isize) -> isize>(f: F) -> isize {
f(5, 6)
}
fn main() {
- let z: int = 7;
- assert_eq!(a(move |x: int, y| x + y + z), 10);
- assert_eq!(b(move |x: int, y| x + y + z), 14);
- assert_eq!(c(move |x: int, y| x + y + z), 18);
+ let z: isize = 7;
+ assert_eq!(a(move |x: isize, y| x + y + z), 10);
+ assert_eq!(b(move |x: isize, y| x + y + z), 14);
+ assert_eq!(c(move |x: isize, y| x + y + z), 18);
}
use std::ops::FnMut;
-fn call_with_2(x: &fn(int) -> int) -> int
+fn call_with_2(x: &fn(isize) -> isize) -> isize
{
x(2) // look ma, no `*`
}
-fn subtract_22(x: int) -> int { x - 22 }
+fn subtract_22(x: isize) -> isize { x - 22 }
pub fn main() {
- let subtract_22: fn(int) -> int = subtract_22;
+ let subtract_22: fn(isize) -> isize = subtract_22;
let z = call_with_2(&subtract_22);
assert_eq!(z, -20);
}
use std::ops::FnMut;
-fn call_with_2<F>(x: &mut F) -> int
- where F : FnMut(int) -> int
+fn call_with_2<F>(x: &mut F) -> isize
+ where F : FnMut(isize) -> isize
{
x(2) // look ma, no `*`
}
use std::ops::FnMut;
-fn make_adder(x: int) -> Box<FnMut(int)->int + 'static> {
+fn make_adder(x: isize) -> Box<FnMut(isize)->isize + 'static> {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
Box::new(move |y| { x + y })
}
use std::ops::FnMut;
-fn make_adder(x: int) -> Box<FnMut(int)->int + 'static> {
+fn make_adder(x: isize) -> Box<FnMut(isize)->isize + 'static> {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
Box::new(move |y| { x + y })
}
// aux-build:unboxed-closures-cross-crate.rs
// pretty-expanded FIXME #23616
-extern crate "unboxed-closures-cross-crate" as ubcc;
+extern crate unboxed_closures_cross_crate as ubcc;
fn main() {
assert_eq!(ubcc::has_closures(), 2_usize);
#![feature(unboxed_closures)]
-static mut DROP_COUNT: uint = 0;
+static mut DROP_COUNT: usize = 0;
-fn drop_count() -> uint {
+fn drop_count() -> usize {
unsafe {
DROP_COUNT
}
}
struct Droppable {
- x: int,
+ x: isize,
}
impl Droppable {
}
}
-fn a<F:Fn(int, int) -> int>(f: F) -> int {
+fn a<F:Fn(isize, isize) -> isize>(f: F) -> isize {
f(1, 2)
}
-fn b<F:FnMut(int, int) -> int>(mut f: F) -> int {
+fn b<F:FnMut(isize, isize) -> isize>(mut f: F) -> isize {
f(3, 4)
}
-fn c<F:FnOnce(int, int) -> int>(f: F) -> int {
+fn c<F:FnOnce(isize, isize) -> isize>(f: F) -> isize {
f(5, 6)
}
fn test_fn() {
{
- a(move |a: int, b| { a + b });
+ a(move |a: isize, b| { a + b });
}
assert_eq!(drop_count(), 0);
{
let z = &Droppable::new();
- a(move |a: int, b| { z; a + b });
+ a(move |a: isize, b| { z; a + b });
assert_eq!(drop_count(), 0);
}
assert_eq!(drop_count(), 1);
{
let z = &Droppable::new();
let zz = &Droppable::new();
- a(move |a: int, b| { z; zz; a + b });
+ a(move |a: isize, b| { z; zz; a + b });
assert_eq!(drop_count(), 1);
}
assert_eq!(drop_count(), 3);
fn test_fn_mut() {
{
- b(move |a: int, b| { a + b });
+ b(move |a: isize, b| { a + b });
}
assert_eq!(drop_count(), 3);
{
let z = &Droppable::new();
- b(move |a: int, b| { z; a + b });
+ b(move |a: isize, b| { z; a + b });
assert_eq!(drop_count(), 3);
}
assert_eq!(drop_count(), 4);
{
let z = &Droppable::new();
let zz = &Droppable::new();
- b(move |a: int, b| { z; zz; a + b });
+ b(move |a: isize, b| { z; zz; a + b });
assert_eq!(drop_count(), 4);
}
assert_eq!(drop_count(), 6);
fn test_fn_once() {
{
- c(move |a: int, b| { a + b });
+ c(move |a: isize, b| { a + b });
}
assert_eq!(drop_count(), 6);
{
let z = Droppable::new();
- c(move |a: int, b| { z; a + b });
+ c(move |a: isize, b| { z; a + b });
assert_eq!(drop_count(), 7);
}
assert_eq!(drop_count(), 7);
{
let z = Droppable::new();
let zz = Droppable::new();
- c(move |a: int, b| { z; zz; a + b });
+ c(move |a: isize, b| { z; zz; a + b });
assert_eq!(drop_count(), 9);
}
assert_eq!(drop_count(), 9);
use std::ops::{Fn,FnMut,FnOnce};
-fn square(x: &int) -> int { (*x) * (*x) }
+fn square(x: &isize) -> isize { (*x) * (*x) }
-fn call_it<F:Fn(&int)->int>(f: &F, x: int) -> int {
+fn call_it<F:Fn(&isize)->isize>(f: &F, x: isize) -> isize {
(*f)(&x)
}
-fn call_it_boxed(f: &Fn(&int) -> int, x: int) -> int {
+fn call_it_boxed(f: &Fn(&isize) -> isize, x: isize) -> isize {
f.call((&x,))
}
-fn call_it_mut<F:FnMut(&int)->int>(f: &mut F, x: int) -> int {
+fn call_it_mut<F:FnMut(&isize)->isize>(f: &mut F, x: isize) -> isize {
(*f)(&x)
}
-fn call_it_once<F:FnOnce(&int)->int>(f: F, x: int) -> int {
+fn call_it_once<F:FnOnce(&isize)->isize>(f: F, x: isize) -> isize {
f(&x)
}
use std::ops::{Fn,FnMut,FnOnce};
-fn square(x: int) -> int { x * x }
+fn square(x: isize) -> isize { x * x }
-fn call_it<F:Fn(int)->int>(f: &F, x: int) -> int {
+fn call_it<F:Fn(isize)->isize>(f: &F, x: isize) -> isize {
f(x)
}
-fn call_it_mut<F:FnMut(int)->int>(f: &mut F, x: int) -> int {
+fn call_it_mut<F:FnMut(isize)->isize>(f: &mut F, x: isize) -> isize {
f(x)
}
-fn call_it_once<F:FnOnce(int)->int>(f: F, x: int) -> int {
+fn call_it_once<F:FnOnce(isize)->isize>(f: F, x: isize) -> isize {
f(x)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that we are able to infer that the type of `x` is `int` based
+// Test that we are able to infer that the type of `x` is `isize` based
// on the expected type from the object.
// pretty-expanded FIXME #23616
}
pub fn main() {
- doit(0, &|x /*: int*/ | { x.to_int(); });
+ doit(0, &|x /*: isize*/ | { x.to_int(); });
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that we are able to infer that the type of `x` is `int` based
+// Test that we are able to infer that the type of `x` is `isize` based
// on the expected type from the object.
// pretty-expanded FIXME #23616
fn doit<T>(val: T, f: &Fn(T)) { f.call((val,)) }
pub fn main() {
- doit(0, &|x /*: int*/ | { x.to_int(); });
+ doit(0, &|x /*: isize*/ | { x.to_int(); });
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Test that we are able to infer that the type of `x` is `int` based
+// Test that we are able to infer that the type of `x` is `isize` based
// on the expected type from the object.
// pretty-expanded FIXME #23616
}
pub fn main() {
- doit(0, &|x /*: int*/ | { x.to_int(); });
+ doit(0, &|x /*: isize*/ | { x.to_int(); });
}
assert_eq!(f.call_mut(()), &x);
#[derive(Clone, Copy, Debug, PartialEq)]
- struct Foo(uint, &'static str);
+ struct Foo(usize, &'static str);
let x = Foo(42, "forty-two");
let mut f = bar(x);
// mutably so we do not get a spurious warning about it not needing to
// be declared mutable (issue #18336 and #18769)
-fn set(x: &mut uint) { *x = 42; }
+fn set(x: &mut usize) { *x = 42; }
fn main() {
{
fn main() {
// FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
- let task: Box<Fn(int) -> int> = Box::new(|x| x);
+ let task: Box<Fn(isize) -> isize> = Box::new(|x| x);
task.call((0, ));
- let mut task: Box<FnMut(int) -> int> = Box::new(|x| x);
+ let mut task: Box<FnMut(isize) -> isize> = Box::new(|x| x);
task(0);
call(|x| x, 22);
}
-fn call<F:FnOnce(int) -> int>(f: F, x: int) -> int {
+fn call<F:FnOnce(isize) -> isize>(f: F, x: isize) -> isize {
f(x)
}
use std::ops::FnMut;
pub fn main() {
- let mut f = |x: int, y: int| -> int { x + y };
+ let mut f = |x: isize, y: isize| -> isize { x + y };
let z = f(1, 2);
assert_eq!(z, 3);
}
#![feature(unboxed_closures)]
-fn a<F:Fn(int, int) -> int>(f: F) -> int {
+fn a<F:Fn(isize, isize) -> isize>(f: F) -> isize {
f(1, 2)
}
-fn b<F:FnMut(int, int) -> int>(mut f: F) -> int {
+fn b<F:FnMut(isize, isize) -> isize>(mut f: F) -> isize {
f(3, 4)
}
-fn c<F:FnOnce(int, int) -> int>(f: F) -> int {
+fn c<F:FnOnce(isize, isize) -> isize>(f: F) -> isize {
f(5, 6)
}
fn main() {
let z = 10;
- assert_eq!(a(move |x: int, y| x + y + z), 13);
- assert_eq!(b(move |x: int, y| x + y + z), 17);
- assert_eq!(c(move |x: int, y| x + y + z), 21);
+ assert_eq!(a(move |x: isize, y| x + y + z), 13);
+ assert_eq!(b(move |x: isize, y| x + y + z), 17);
+ assert_eq!(c(move |x: isize, y| x + y + z), 21);
}
pub fn main() {
let mut a = 7;
let b = &mut a;
- replace_map(b, |x: uint| x * 2);
+ replace_map(b, |x: usize| x * 2);
assert_eq!(*b, 14);
}
// cross-crate
pub fn main() {
- fn count(st: &mut uint) -> Option<uint> {
+ fn count(st: &mut usize) -> Option<usize> {
if *st < 10 {
let ret = Some(*st);
*st += 1;
}
}
-pub fn main() { null::<int>(); }
+pub fn main() { null::<isize>(); }
#![feature(box_syntax)]
struct X {
- a: int
+ a: isize
}
trait Changer {
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct J { j: int }
+struct J { j: isize }
pub fn main() {
let i: Box<_> = box J {
#![feature(box_syntax)]
pub fn main() {
- enum t { t1(int), t2(int), }
+ enum t { t1(isize), t2(isize), }
let _x: Box<_> = box t::t1(10);
// pretty-expanded FIXME #23616
pub fn main() {
- let _: Box<int>;
+ let _: Box<isize>;
}
-fn f(_i: Box<int>) -> Box<int> {
+fn f(_i: Box<isize>) -> Box<isize> {
panic!();
}
#![feature(box_patterns)]
#![feature(box_syntax)]
-struct Foo { a: int, b: int }
+struct Foo { a: isize, b: isize }
pub fn main() {
let box Foo{a, b} = box Foo{a: 100, b: 200};
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f(i: Box<int>) {
+fn f(i: Box<isize>) {
assert_eq!(*i, 100);
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f(i: &mut Box<int>) {
+fn f(i: &mut Box<isize>) {
*i = box 200;
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f(i: Box<int>) {
+fn f(i: Box<isize>) {
assert_eq!(*i, 100);
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-fn f() -> Box<int> {
+fn f() -> Box<isize> {
box 100
}
#![feature(box_syntax)]
fn test1() {
- enum bar { u(Box<int>), w(int), }
+ enum bar { u(Box<isize>), w(isize), }
let x = bar::u(box 10);
assert!(match x {
pub trait EventLoop { fn foo(&self) {} }
pub struct UvEventLoop {
- uvio: int
+ uvio: isize
}
impl EventLoop for UvEventLoop { }
#![feature(box_patterns)]
#![feature(box_syntax)]
-struct Foo {a: int, b: uint}
+struct Foo {a: isize, b: usize}
-enum bar { u(Box<Foo>), w(int), }
+enum bar { u(Box<Foo>), w(isize), }
pub fn main() {
assert!(match bar::u(box Foo{a: 10, b: 40}) {
- bar::u(box Foo{a: a, b: b}) => { a + (b as int) }
+ bar::u(box Foo{a: a, b: b}) => { a + (b as isize) }
_ => { 66 }
} == 50);
}
#![allow(unknown_features)]
#![feature(box_syntax)]
-enum bar { u(Box<int>), w(int), }
+enum bar { u(Box<isize>), w(isize), }
pub fn main() {
assert!(match bar::u(box 10) {
#![allow(unknown_features)]
#![feature(box_syntax)]
-struct X { x: int }
+struct X { x: isize }
pub fn main() {
let x: Box<_> = box X {x: 1};
use std::sync::mpsc::{channel, Sender};
use std::thread;
-fn child(tx: &Sender<Box<uint>>, i: uint) {
+fn child(tx: &Sender<Box<usize>>, i: usize) {
tx.send(box i).unwrap();
}
// pretty-expanded FIXME #23616
-fn good(_a: &int) {
+fn good(_a: &isize) {
}
-// unnamed argument &int is now parse x: &int
+// unnamed argument &isize is now parse x: &isize
-fn called<F>(_f: F) where F: FnOnce(&int) {
+fn called<F>(_f: F) where F: FnOnce(&isize) {
}
pub fn main() {
// pretty-expanded FIXME #23616
-fn f(x: *const int) {
+fn f(x: *const isize) {
unsafe {
assert_eq!(*x, 3);
}
f: X,
}
struct S3<X: ?Sized> {
- f1: int,
+ f1: isize,
f2: X,
}
enum E<X: ?Sized> {
V1(X),
V2{x: X},
- V3(int, X),
- V4{u: int, x: X},
+ V3(isize, X),
+ V4{u: isize, x: X},
}
pub fn main() {
// Issue #1706
// pretty-expanded FIXME #23616
-extern crate "std" as stdlib;
+extern crate std as stdlib;
pub fn main() {}
// pretty-expanded FIXME #23616
mod foo {
- pub fn x() -> int { return 1; }
+ pub fn x() -> isize { return 1; }
}
mod bar {
- pub fn y() -> int { return 1; }
+ pub fn y() -> isize { return 1; }
}
pub fn main() { foo::x(); bar::y(); }
// pretty-expanded FIXME #23616
-impl foo for int { fn foo(&self) -> int { 10 } }
-trait foo { fn foo(&self) -> int; }
+impl foo for isize { fn foo(&self) -> isize { 10 } }
+trait foo { fn foo(&self) -> isize; }
pub fn main() {}
-fn foo<T>(o: myoption<T>) -> int {
- let mut x: int = 5;
+fn foo<T>(o: myoption<T>) -> isize {
+ let mut x: isize = 5;
match o {
myoption::none::<T> => { }
myoption::some::<T>(_t) => { x += 1; }
-fn foo<T>(o: myoption<T>) -> int {
- let mut x: int;
+fn foo<T>(o: myoption<T>) -> isize {
+ let mut x: isize;
match o {
myoption::none::<T> => { panic!(); }
myoption::some::<T>(_t) => { x = 5; }
#![no_std]
extern crate std;
-extern crate "std" as zed;
+extern crate std as zed;
use std::str;
use zed::str as x;
}
#[start]
-pub fn start(_: int, _: *const *const u8) -> int { 0 }
+pub fn start(_: isize, _: *const *const u8) -> isize { 0 }
let y_diaeresis: char = 'ÿ'; // 0xff
let pi: char = 'Π'; // 0x3a0
- assert_eq!(yen as int, 0xa5);
- assert_eq!(c_cedilla as int, 0xe7);
- assert_eq!(thorn as int, 0xfe);
- assert_eq!(y_diaeresis as int, 0xff);
- assert_eq!(pi as int, 0x3a0);
+ assert_eq!(yen as isize, 0xa5);
+ assert_eq!(c_cedilla as isize, 0xe7);
+ assert_eq!(thorn as isize, 0xfe);
+ assert_eq!(y_diaeresis as isize, 0xff);
+ assert_eq!(pi as isize, 0x3a0);
- assert_eq!(pi as int, '\u{3a0}' as int);
- assert_eq!('\x0a' as int, '\n' as int);
+ assert_eq!(pi as isize, '\u{3a0}' as isize);
+ assert_eq!('\x0a' as isize, '\n' as isize);
let bhutan: String = "འབྲུག་ཡུལ།".to_string();
let japan: String = "日本".to_string();
let austria_e: String = "\u{d6}sterreich".to_string();
let oo: char = 'Ö';
- assert_eq!(oo as int, 0xd6);
+ assert_eq!(oo as isize, 0xd6);
fn check_str_eq(a: String, b: String) {
- let mut i: int = 0;
+ let mut i: isize = 0;
for ab in a.bytes() {
println!("{}", i);
println!("{}", ab);
- let bb: u8 = b.as_bytes()[i as uint];
+ let bb: u8 = b.as_bytes()[i as usize];
println!("{}", bb);
assert_eq!(ab, bb);
i += 1;
assert_eq!(საჭმელად_გემრიელი_სადილი(), 0);
}
-fn საჭმელად_გემრიელი_სადილი() -> int {
+fn საჭმელად_გემრიელი_სადილი() -> isize {
// Lunch in several languages.
// pretty-expanded FIXME #23616
enum Foo {
- Bar { x: int },
- Baz { y: int }
+ Bar { x: isize },
+ Baz { y: isize }
}
pub fn main() { }
use std::vec;
pub fn main() {
- let a: Vec<int> = vec!(1, 2, 3, 4, 5);
- let b: Vec<int> = vec!(6, 7, 8, 9, 0);
- let mut v: Vec<int> = a;
+ let a: Vec<isize> = vec!(1, 2, 3, 4, 5);
+ let b: Vec<isize> = vec!(6, 7, 8, 9, 0);
+ let mut v: Vec<isize> = a;
v.push_all(&b);
println!("{}", v[9]);
assert_eq!(v[0], 1);
pub fn main() {
// Tests for indexing into box/& [T; n]
- let x: [int; 3] = [1, 2, 3];
- let mut x: Box<[int; 3]> = box x;
+ let x: [isize; 3] = [1, 2, 3];
+ let mut x: Box<[isize; 3]> = box x;
assert!(x[0] == 1);
assert!(x[1] == 2);
assert!(x[2] == 3);
assert!(x[1] == 45);
assert!(x[2] == 3);
- let mut x: [int; 3] = [1, 2, 3];
- let x: &mut [int; 3] = &mut x;
+ let mut x: [isize; 3] = [1, 2, 3];
+ let x: &mut [isize; 3] = &mut x;
assert!(x[0] == 1);
assert!(x[1] == 2);
assert!(x[2] == 3);
use std::mem::size_of;
pub fn main() {
- let x: [int; 4] = [1, 2, 3, 4];
+ let x: [isize; 4] = [1, 2, 3, 4];
assert_eq!(x[0], 1);
assert_eq!(x[1], 2);
assert_eq!(x[2], 3);
pub fn main() {
- let mut later: Vec<int> ;
+ let mut later: Vec<isize> ;
if true { later = vec!(1); } else { later = vec!(2); }
println!("{}", later[0]);
}
#![feature(lang_items, start, no_std, core, libc, collections)]
#![no_std]
-extern crate "std" as other;
+extern crate std as other;
#[macro_use]
extern crate core;
// Issue #16806
#[start]
-fn start(_argc: int, _argv: *const *const u8) -> int {
+fn start(_argc: isize, _argv: *const *const u8) -> isize {
let x: Vec<u8> = vec![0, 1, 2];
match x.last() {
Some(&2) => (),
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
pub fn main() {
let x = [1, 2, 3];
match x {
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
fn a() {
let x = [1, 2, 3];
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
fn foldl<T, U, F>(values: &[T],
initial: U,
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![feature(slice_patterns)]
+
pub fn main() {
let x = &[1, 2, 3, 4, 5];
- let x: &[int] = &[1, 2, 3, 4, 5];
+ let x: &[isize] = &[1, 2, 3, 4, 5];
if !x.is_empty() {
let el = match x {
[1, ref tail..] => &tail[0],
// pretty-expanded FIXME #23616
#![feature(advanced_slice_patterns)]
+#![feature(slice_patterns)]
fn a() {
let x = [1];
}
fn e() {
- let x: &[int] = &[1, 2, 3];
+ let x: &[isize] = &[1, 2, 3];
match x {
[1, 2] => (),
[..] => ()
// pretty-expanded FIXME #23616
-pub fn main() { let _a = [0; 1 as uint]; }
+pub fn main() { let _a = [0; 1 as usize]; }
// Make sure that destructors get run on slice literals
struct foo<'a> {
- x: &'a Cell<int>,
+ x: &'a Cell<isize>,
}
#[unsafe_destructor]
}
}
-fn foo(x: &Cell<int>) -> foo {
+fn foo(x: &Cell<isize>) -> foo {
foo {
x: x
}
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
struct Foo {
string: String
}
assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string());
let foo = vec!(3, 4);
- let bar: &[int] = &[4, 5];
+ let bar: &[isize] = &[4, 5];
assert_eq!(format!("{:?}", foo), "[3, 4]");
assert_eq!(format!("{:?}", bar), "[4, 5]");
// pretty-expanded FIXME #23616
pub fn main() {
- let v: Vec<int> = vec!(10, 20);
+ let v: Vec<isize> = vec!(10, 20);
assert_eq!(v[0], 10);
assert_eq!(v[1], 20);
- let mut x: uint = 0;
+ let mut x: usize = 0;
assert_eq!(v[x], 10);
assert_eq!(v[x + 1], 20);
x = x + 1;
#![allow(unknown_features)]
#![feature(box_syntax)]
-pub fn main() { let _quux: Box<Vec<uint>> = box Vec::new(); }
+pub fn main() { let _quux: Box<Vec<usize>> = box Vec::new(); }
mod libc {
extern {
- pub fn malloc(size: int) -> *const u8;
+ pub fn malloc(size: isize) -> *const u8;
}
}
// pretty-expanded FIXME #23616
-extern crate "weak-lang-items" as other;
+extern crate weak_lang_items as other;
use std::thread;
}
fn notsure() {
- let mut _x: int;
+ let mut _x: isize;
let mut _y = (_x = 0) == (_x = 0);
let mut _z = (_x = 0) < (_x = 0);
let _a = (_x += 0) == (_x = 0);
let _b = swap(&mut _y, &mut _z) == swap(&mut _y, &mut _z);
}
-fn canttouchthis() -> uint {
+fn canttouchthis() -> usize {
fn p() -> bool { true }
let _a = (assert!((true)) == (assert!(p())));
let _c = (assert!((p())) == ());
// pretty-expanded FIXME #23616
pub struct Context<'tcx> {
- vec: &'tcx Vec<int>
+ vec: &'tcx Vec<isize>
}
-pub type Cmd<'a> = &'a int;
+pub type Cmd<'a> = &'a isize;
pub type DecodeInlinedItem<'a> =
- Box<for<'tcx> FnMut(Cmd, &Context<'tcx>) -> Result<&'tcx int, ()> + 'a>;
+ Box<for<'tcx> FnMut(Cmd, &Context<'tcx>) -> Result<&'tcx isize, ()> + 'a>;
fn foo(d: DecodeInlinedItem) {
}
trait TheTrait { fn dummy(&self) { } }
-impl TheTrait for &'static int { }
+impl TheTrait for &'static isize { }
fn foo<'a,T>(_: &'a T) where &'a T : TheTrait { }
fn bar<T>(_: &'static T) where &'static T : TheTrait { }
fn main() {
- static x: int = 1;
+ static x: isize = 1;
foo(&x);
bar(&x);
}
// pretty-expanded FIXME #23616
-struct A<'a, 'b> where 'a : 'b { x: &'a int, y: &'b int }
+struct A<'a, 'b> where 'a : 'b { x: &'a isize, y: &'b isize }
fn main() {
let x = 1;
println!("{}", equal(&1, &2));
println!("{}", equal(&1, &1));
println!("{}", "hello".equal(&"hello"));
- println!("{}", "hello".equals::<int,&str>(&1, &1, &"foo", &"bar"));
+ println!("{}", "hello".equals::<isize,&str>(&1, &1, &"foo", &"bar"));
}
// pretty-expanded FIXME #23616
-fn foo<'a, I>(mut it: I) where I: Iterator<Item=&'a int> {}
+fn foo<'a, I>(mut it: I) where I: Iterator<Item=&'a isize> {}
fn main() {
foo([1, 2].iter());
println!("{}", equal(&1, &2));
println!("{}", equal(&1, &1));
println!("{}", "hello".equal(&"hello"));
- println!("{}", "hello".equals::<int,&str>(&1, &1, &"foo", &"bar"));
+ println!("{}", "hello".equals::<isize,&str>(&1, &1, &"foo", &"bar"));
}
// pretty-expanded FIXME #23616
-pub fn main() { let x: int = 10; while x == 10 && x == 11 { let _y = 0xf00_usize; } }
+pub fn main() { let x: isize = 10; while x == 10 && x == 11 { let _y = 0xf00_usize; } }
use std::collections::BinaryHeap;
-fn make_pq() -> BinaryHeap<int> {
+fn make_pq() -> BinaryHeap<isize> {
BinaryHeap::from_vec(vec![1,2,3])
}
#![allow(unused_variable)]
pub fn main() {
- let mut y: int = 42;
- let mut z: int = 42;
- let mut x: int;
+ let mut y: isize = 42;
+ let mut z: isize = 42;
+ let mut x: isize;
while z < 50 {
z += 1;
while false { x = y; y = z; }
#[derive(PartialEq)]
enum t { a, b(String), }
-fn make(i: int) -> t {
+fn make(i: isize) -> t {
if i > 10 { return t::a; }
let mut s = String::from_str("hello");
// Ensure s is non-const.
pub fn main() {
- let mut i: int = 90;
+ let mut i: isize = 90;
while i < 100 {
println!("{}", i);
i = i + 1;
if i == 95 {
- let _v: Vec<int> =
+ let _v: Vec<isize> =
vec!(1, 2, 3, 4, 5); // we check that it is freed by break
println!("breaking");
pub fn main() {
- let mut x: int = 10;
- let mut y: int = 0;
+ let mut x: isize = 10;
+ let mut y: isize = 0;
while y < x { println!("{}", y); println!("hello"); y = y + 1; }
while x > 0 {
println!("goodbye");
use std::sync::Mutex;
-struct Point {x: int, y: int, z: int}
+struct Point {x: isize, y: isize, z: isize}
fn f(p: &mut Point) { p.z = 13; }
#[cfg(windows)]
mod kernel32 {
extern "system" {
- pub fn SetLastError(err: uint);
- pub fn GetLastError() -> uint;
+ pub fn SetLastError(err: usize);
+ pub fn GetLastError() -> usize;
}
}
pub type HANDLE = u32;
pub type DWORD = u32;
pub type SIZE_T = u32;
-pub type LPVOID = uint;
+pub type LPVOID = usize;
pub type BOOL = u8;
#[cfg(windows)]
// pretty-expanded FIXME #23616
-extern crate "xcrate_address_insignificant" as foo;
+extern crate xcrate_address_insignificant as foo;
pub fn main() {
assert_eq!(foo::foo::<f64>(), foo::bar());
// pretty-expanded FIXME #23616
-extern crate "xcrate-trait-lifetime-param" as other;
+extern crate xcrate_trait_lifetime_param as other;
struct Reader<'a> {
b : &'a [u8]
use std::thread;
pub fn main() {
- let mut i: int = 0;
+ let mut i: isize = 0;
while i < 100 { i = i + 1; println!("{}", i); thread::yield_now(); }
}
#![feature(unsafe_no_drop_flag)]
-static mut destructions : int = 3;
+static mut destructions : isize = 3;
pub fn foo() {
#[unsafe_no_drop_flag]
// pretty-expanded FIXME #23616
+#![feature(slice_patterns)]
+
fn main() {
let x = [(), ()];
projects / rust.git / commitdiff