Skip to content

Commit 2a4cc59

Browse files
committed
---
yaml --- r: 151289 b: refs/heads/try2 c: 7e53af3 h: refs/heads/master i: 151287: 45ed908 v: v3
1 parent 2efcbff commit 2a4cc59

39 files changed

+170
-565
lines changed

[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
55
refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
66
refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
77
refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
8-
refs/heads/try2: 028159ead403c09efcaa2b0bb0738d33209c3950
8+
refs/heads/try2: 7e53af35b1d521a4d0f24d964074112266a897b8
99
refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
1010
refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
1111
refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/LICENSE-MIT

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
Copyright (c) 2014 The Rust Project Developers
1+
Copyright (c) 2006-2009 Graydon Hoare
2+
Copyright (c) 2009-2014 Mozilla Foundation
23

34
Permission is hereby granted, free of charge, to any
45
person obtaining a copy of this software and associated

branches/try2/src/doc/guide-pointers.md

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -186,7 +186,7 @@ enum List<T> {
186186
Nil,
187187
Cons(T, ~List<T>),
188188
}
189-
189+
190190
fn main() {
191191
let list: List<int> = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
192192
println!("{:?}", list);
@@ -251,7 +251,7 @@ struct.
251251

252252
> **Note**: the `@` form of managed pointers is deprecated and behind a
253253
> feature gate (it requires a `#![feature(managed_pointers)]` attribute on
254-
> the crate root). There are replacements, currently
254+
> the crate root; remember the semicolon!). There are replacements, currently
255255
> there is `std::rc::Rc` and `std::gc::Gc` for shared ownership via reference
256256
> counting and garbage collection respectively.
257257
@@ -266,7 +266,7 @@ struct Point {
266266
x: int,
267267
y: int,
268268
}
269-
269+
270270
fn main() {
271271
let a = ~Point { x: 10, y: 20 };
272272
let b = a;
@@ -297,7 +297,7 @@ struct Point {
297297
x: int,
298298
y: int,
299299
}
300-
300+
301301
fn main() {
302302
let a = @Point { x: 10, y: 20 };
303303
let b = a;
@@ -361,7 +361,7 @@ So how is this hard? Well, because we're ignoring ownership, the compiler needs
361361
to take great care to make sure that everything is safe. Despite their complete
362362
safety, a reference's representation at runtime is the same as that of
363363
an ordinary pointer in a C program. They introduce zero overhead. The compiler
364-
does all safety checks at compile time.
364+
does all safety checks at compile time.
365365

366366
This theory is called 'region pointers,' and involve a concept called
367367
'lifetimes'. Here's the simple explanation: would you expect this code to
@@ -477,7 +477,7 @@ fn main() {
477477
You may think that this gives us terrible performance: return a value and then
478478
immediately box it up?!?! Isn't that the worst of both worlds? Rust is smarter
479479
than that. There is no copy in this code. `main` allocates enough room for the
480-
`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
480+
`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
481481
the value straight into that pointer. This writes the return value directly into
482482
the allocated box.
483483

branches/try2/src/doc/guide-tasks.md

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,8 +101,6 @@ fn print_message() { println!("I am running in a different task!"); }
101101
spawn(print_message);
102102
103103
// Print something more profound in a different task using a lambda expression
104-
// This uses the proc() keyword to assign to spawn a function with no name
105-
// That function will call println!(...) as requested
106104
spawn(proc() println!("I am also running in a different task!") );
107105
~~~~
108106

branches/try2/src/doc/tutorial.md

Lines changed: 17 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -1720,103 +1720,38 @@ environment (sometimes referred to as "capturing" variables in their
17201720
environment). For example, you couldn't write the following:
17211721
17221722
~~~~ {.ignore}
1723-
let x = 3;
1723+
let foo = 10;
17241724
1725-
// `fun` cannot refer to `x`
1726-
fn fun() -> () { println!("{}", x); }
1725+
fn bar() -> int {
1726+
return foo; // `bar` cannot refer to `foo`
1727+
}
17271728
~~~~
17281729
1729-
A _closure_ does support accessing the enclosing scope; below we will create
1730-
2 _closures_ (nameless functions). Compare how `||` replaces `()` and how
1731-
they try to access `x`:
1732-
1733-
~~~~ {.ignore}
1734-
let x = 3;
1735-
1736-
// `fun` is an invalid definition
1737-
fn fun () -> () { println!("{}", x) } // cannot capture from enclosing scope
1738-
let closure = || -> () { println!("{}", x) }; // can capture from enclosing scope
1730+
Rust also supports _closures_, functions that can access variables in
1731+
the enclosing scope.
17391732
1740-
// `fun_arg` is an invalid definition
1741-
fn fun_arg (arg: int) -> () { println!("{}", arg + x) } // cannot capture
1742-
let closure_arg = |arg: int| -> () { println!("{}", arg + x) }; // can capture
1743-
// ^
1744-
// Requires a type because the implementation needs to know which `+` to use.
1745-
// In the future, the implementation may not need the help.
1733+
~~~~
1734+
fn call_closure_with_ten(b: |int|) { b(10); }
17461735
1747-
fun(); // Still won't work
1748-
closure(); // Prints: 3
1736+
let captured_var = 20;
1737+
let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
17491738
1750-
fun_arg(7); // Still won't work
1751-
closure_arg(7); // Prints: 10
1739+
call_closure_with_ten(closure);
17521740
~~~~
17531741
17541742
Closures begin with the argument list between vertical bars and are followed by
17551743
a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
17561744
considered a single expression: it evaluates to the result of the last
17571745
expression it contains if that expression is not followed by a semicolon,
1758-
otherwise the block evaluates to `()`, the unit value.
1759-
1760-
In general, return types and all argument types must be specified
1761-
explicitly for function definitions. (As previously mentioned in the
1762-
[Functions section](#functions), omitting the return type from a
1763-
function declaration is synonymous with an explicit declaration of
1764-
return type unit, `()`.)
1765-
1766-
~~~~ {.ignore}
1767-
fn fun (x: int) { println!("{}", x) } // this is same as saying `-> ()`
1768-
fn square(x: int) -> uint { (x * x) as uint } // other return types are explicit
1769-
1770-
// Error: mismatched types: expected `()` but found `uint`
1771-
fn badfun(x: int) { (x * x) as uint }
1772-
~~~~
1773-
1774-
On the other hand, the compiler can usually infer both the argument
1775-
and return types for a closure expression; therefore they are often
1776-
omitted, since both a human reader and the compiler can deduce the
1777-
types from the immediate context. This is in contrast to function
1778-
declarations, which require types to be specified and are not subject
1779-
to type inference. Compare:
1746+
otherwise the block evaluates to `()`.
17801747
1781-
~~~~ {.ignore}
1782-
// `fun` as a function declaration cannot infer the type of `x`, so it must be provided
1783-
fn fun (x: int) { println!("{}", x) }
1784-
let closure = |x | { println!("{}", x) }; // infers `x: int`, return type `()`
1785-
1786-
// For closures, omitting a return type is *not* synonymous with `-> ()`
1787-
let add_3 = |y | { 3i + y }; // infers `y: int`, return type `int`.
1788-
1789-
fun(10); // Prints 10
1790-
closure(20); // Prints 20
1791-
closure(add_3(30)); // Prints 33
1748+
The types of the arguments are generally omitted, as is the return type,
1749+
because the compiler can almost always infer them. In the rare case where the
1750+
compiler needs assistance, though, the arguments and return types may be
1751+
annotated.
17921752
1793-
fun("String"); // Error: mismatched types
1794-
1795-
// Error: mismatched types
1796-
// inference already assigned `closure` the type `|int| -> ()`
1797-
closure("String");
17981753
~~~~
1799-
1800-
In cases where the compiler needs assistance, the arguments and return
1801-
types may be annotated on closures, using the same notation as shown
1802-
earlier. In the example below, since different types provide an
1803-
implementation for the operator `*`, the argument type for the `x`
1804-
parameter must be explicitly provided.
1805-
1806-
~~~~{.ignore}
1807-
// Error: the type of `x` must be known to be used with `x * x`
1808-
let square = |x | -> uint { (x * x) as uint };
1809-
~~~~
1810-
1811-
In the corrected version, the argument type is explicitly annotated,
1812-
while the return type can still be inferred.
1813-
1814-
~~~~
1815-
let square_explicit = |x: int| -> uint { (x * x) as uint };
1816-
let square_infer = |x: int| { (x * x) as uint };
1817-
1818-
println!("{}", square_explicit(20)); // 400
1819-
println!("{}", square_infer(-20)); // 400
1754+
let square = |x: int| -> uint { (x * x) as uint };
18201755
~~~~
18211756
18221757
There are several forms of closure, each with its own role. The most

branches/try2/src/etc/emacs/README.md

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,12 @@ To install manually, check out this repository and add this to your
1212

1313
```lisp
1414
(add-to-list 'load-path "/path/to/rust-mode/")
15-
(require 'rust-mode)
15+
(autoload 'rust-mode "rust-mode" nil t)
16+
(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
1617
```
1718

18-
`rust-mode` will automatically be associated with `.rs` files. To enable it
19-
explicitly, do <kbd>M-x rust-mode</kbd>.
19+
This associates `rust-mode` with `.rs` files. To enable it explicitly, do
20+
<kbd>M-x rust-mode</kbd>.
2021

2122
### `package.el` installation via Marmalade or MELPA
2223

branches/try2/src/librustc/front/feature_gate.rs

Lines changed: 2 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -59,10 +59,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
5959

6060
("quad_precision_float", Active),
6161

62-
// A temporary feature gate used to enable parser extensions needed
63-
// to bootstrap fix for #5723.
64-
("issue_5723_bootstrap", Active),
65-
6662
// These are used to test this portion of the compiler, they don't actually
6763
// mean anything
6864
("test_accepted_feature", Accepted),
@@ -84,16 +80,14 @@ enum Status {
8480
/// A set of features to be used by later passes.
8581
pub struct Features {
8682
pub default_type_params: Cell<bool>,
87-
pub quad_precision_float: Cell<bool>,
88-
pub issue_5723_bootstrap: Cell<bool>,
83+
pub quad_precision_float: Cell<bool>
8984
}
9085

9186
impl Features {
9287
pub fn new() -> Features {
9388
Features {
9489
default_type_params: Cell::new(false),
95-
quad_precision_float: Cell::new(false),
96-
issue_5723_bootstrap: Cell::new(false),
90+
quad_precision_float: Cell::new(false)
9791
}
9892
}
9993
}
@@ -373,5 +367,4 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
373367

374368
sess.features.default_type_params.set(cx.has_feature("default_type_params"));
375369
sess.features.quad_precision_float.set(cx.has_feature("quad_precision_float"));
376-
sess.features.issue_5723_bootstrap.set(cx.has_feature("issue_5723_bootstrap"));
377370
}

branches/try2/src/librustc/middle/reachable.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -270,12 +270,11 @@ impl<'a> ReachableContext<'a> {
270270

271271
// Statics with insignificant addresses are not reachable
272272
// because they're inlined specially into all other crates.
273-
ast::ItemStatic(_, _, init) => {
273+
ast::ItemStatic(..) => {
274274
if attr::contains_name(item.attrs.as_slice(),
275275
"address_insignificant") {
276276
self.reachable_symbols.remove(&search_item);
277277
}
278-
visit::walk_expr(self, init, ());
279278
}
280279

281280
// These are normal, nothing reachable about these

branches/try2/src/librustc/middle/resolve.rs

Lines changed: 20 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ use metadata::decoder::{DefLike, DlDef, DlField, DlImpl};
1616
use middle::lang_items::LanguageItems;
1717
use middle::lint::{UnnecessaryQualification, UnusedImports};
1818
use middle::pat_util::pat_bindings;
19-
use util::nodemap::{NodeMap, DefIdSet, FnvHashMap};
19+
use util::nodemap::{NodeMap, DefIdSet, FnvHashSet};
2020

2121
use syntax::ast::*;
2222
use syntax::ast;
@@ -821,7 +821,7 @@ fn Resolver<'a>(session: &'a Session,
821821

822822
graph_root: graph_root,
823823

824-
method_map: RefCell::new(FnvHashMap::new()),
824+
method_set: RefCell::new(FnvHashSet::new()),
825825
structs: HashSet::new(),
826826

827827
unresolved_imports: 0,
@@ -860,7 +860,7 @@ struct Resolver<'a> {
860860

861861
graph_root: NameBindings,
862862

863-
method_map: RefCell<FnvHashMap<(Name, DefId), ast::ExplicitSelf_>>,
863+
method_set: RefCell<FnvHashSet<(Name, DefId)>>,
864864
structs: HashSet<DefId>,
865865

866866
// The number of imports that are currently unresolved.
@@ -1371,8 +1371,10 @@ impl<'a> Resolver<'a> {
13711371
ty_m.span);
13721372
method_name_bindings.define_value(def, ty_m.span, true);
13731373

1374-
self.method_map.borrow_mut().insert((ident.name, def_id),
1375-
ty_m.explicit_self.node);
1374+
// Add it to the trait info if not static.
1375+
if ty_m.explicit_self.node != SelfStatic {
1376+
self.method_set.borrow_mut().insert((ident.name, def_id));
1377+
}
13761378
}
13771379

13781380
name_bindings.define_type(DefTrait(def_id), sp, is_public);
@@ -1658,8 +1660,10 @@ impl<'a> Resolver<'a> {
16581660
trait method '{}'",
16591661
token::get_ident(method_name));
16601662

1661-
self.method_map.borrow_mut().insert((method_name.name, def_id), explicit_self);
1662-
1663+
// Add it to the trait info if not static.
1664+
if explicit_self != SelfStatic {
1665+
self.method_set.borrow_mut().insert((method_name.name, def_id));
1666+
}
16631667
if is_exported {
16641668
self.external_exports.insert(method_def_id);
16651669
}
@@ -3824,8 +3828,7 @@ impl<'a> Resolver<'a> {
38243828
TraitTyParamBound(ref tref) => {
38253829
self.resolve_trait_reference(id, tref, TraitBoundingTypeParameter)
38263830
}
3827-
StaticRegionTyParamBound => {}
3828-
OtherRegionTyParamBound(_) => {}
3831+
RegionTyParamBound => {}
38293832
}
38303833
}
38313834

@@ -4715,16 +4718,10 @@ impl<'a> Resolver<'a> {
47154718
match containing_module.kind.get() {
47164719
TraitModuleKind | ImplModuleKind => {
47174720
match containing_module.def_id.get() {
4718-
Some(def_id) => {
4719-
match self.method_map.borrow().find(&(ident.name, def_id)) {
4720-
Some(x) if *x == SelfStatic => (),
4721-
None => (),
4722-
_ => {
4723-
debug!("containing module was a trait or impl \
4721+
Some(def_id) if self.method_set.borrow().contains(&(ident.name, def_id)) => {
4722+
debug!("containing module was a trait or impl \
47244723
and name was a method -> not resolved");
4725-
return None;
4726-
}
4727-
}
4724+
return None;
47284725
},
47294726
_ => (),
47304727
}
@@ -5113,9 +5110,9 @@ impl<'a> Resolver<'a> {
51135110
// Look for the current trait.
51145111
match self.current_trait_refs {
51155112
Some(ref trait_def_ids) => {
5116-
let method_map = self.method_map.borrow();
5113+
let method_set = self.method_set.borrow();
51175114
for &trait_def_id in trait_def_ids.iter() {
5118-
if method_map.contains_key(&(name, trait_def_id)) {
5115+
if method_set.contains(&(name, trait_def_id)) {
51195116
add_trait_info(&mut found_traits, trait_def_id, name);
51205117
}
51215118
}
@@ -5129,7 +5126,7 @@ impl<'a> Resolver<'a> {
51295126
self.populate_module_if_necessary(&search_module);
51305127

51315128
{
5132-
let method_map = self.method_map.borrow();
5129+
let method_set = self.method_set.borrow();
51335130
for (_, child_names) in search_module.children.borrow().iter() {
51345131
let def = match child_names.def_for_namespace(TypeNS) {
51355132
Some(def) => def,
@@ -5139,7 +5136,7 @@ impl<'a> Resolver<'a> {
51395136
DefTrait(trait_def_id) => trait_def_id,
51405137
_ => continue,
51415138
};
5142-
if method_map.contains_key(&(name, trait_def_id)) {
5139+
if method_set.contains(&(name, trait_def_id)) {
51435140
add_trait_info(&mut found_traits, trait_def_id, name);
51445141
}
51455142
}
@@ -5155,7 +5152,7 @@ impl<'a> Resolver<'a> {
51555152
Some(DefTrait(trait_def_id)) => trait_def_id,
51565153
Some(..) | None => continue,
51575154
};
5158-
if self.method_map.borrow().contains_key(&(name, did)) {
5155+
if self.method_set.borrow().contains(&(name, did)) {
51595156
add_trait_info(&mut found_traits, did, name);
51605157
self.used_imports.insert((import.type_id, TypeNS));
51615158
}

0 commit comments

Comments
 (0)