---

yaml
---
r: 152770
b: refs/heads/try2
c: 7be2019
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 58bf8b2155dc2ece0cee2bc2f60c72ea60d75af3
+refs/heads/try2: 7be2019428ff888ea26075a065fa3cebb66c5ead
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -451,7 +451,6 @@ in the same format as a C:
 
 ```
 #![no_std]
-#![feature(lang_items)]
 
 // Pull in the system libc library for what crt0.o likely requires
 extern crate libc;
@@ -478,7 +477,6 @@ compiler's name mangling too:
 ```ignore
 #![no_std]
 #![no_main]
-#![feature(lang_items)]
 
 extern crate libc;
 
@@ -530,7 +528,6 @@ vectors provided from C, using idiomatic Rust practices.
 ```
 #![no_std]
 #![feature(globs)]
-#![feature(lang_items)]
 
 # extern crate libc;
 extern crate core;
@@ -622,9 +619,6 @@ 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;
 
@@ -653,7 +647,6 @@ sugar for dynamic allocations via `malloc` and `free`:
 
 ```
 #![no_std]
-#![feature(lang_items)]
 
 extern crate libc;
 

branches/try2/src/doc/rust.md

@@ -160,7 +160,7 @@ block_comment_body : [block_comment | character] * ;
 line_comment : "//" non_eol * ;
 ~~~~
 
-Comments in Rust code follow the general C++ style of line and block-comment forms.
+Comments in Rust code follow the general C++ style of line and block-comment forms. 
 Nested block comments are supported.
 
 Line comments beginning with exactly _three_ slashes (`///`), and block
@@ -3004,7 +3004,7 @@ ten_times(|j| println!("hello, {}", j));
 ### While loops
 
 ~~~~ {.ebnf .gram}
-while_expr : "while" no_struct_literal_expr '{' block '}' ;
+while_expr : "while" expr '{' block '}' ;
 ~~~~
 
 A `while` loop begins by evaluating the boolean loop conditional expression.
@@ -3071,7 +3071,7 @@ A `continue` expression is only permitted in the body of a loop.
 ### For expressions
 
 ~~~~ {.ebnf .gram}
-for_expr : "for" pat "in" no_struct_literal_expr '{' block '}' ;
+for_expr : "for" pat "in" expr '{' block '}' ;
 ~~~~
 
 A `for` expression is a syntactic construct for looping over elements
@@ -3105,7 +3105,7 @@ for i in range(0u, 256) {
 ### If expressions
 
 ~~~~ {.ebnf .gram}
-if_expr : "if" no_struct_literal_expr '{' block '}'
+if_expr : "if" expr '{' block '}'
           else_tail ? ;
 
 else_tail : "else" [ if_expr
@@ -3126,7 +3126,7 @@ then any `else` block is executed.
 ### Match expressions
 
 ~~~~ {.ebnf .gram}
-match_expr : "match" no_struct_literal_expr '{' match_arm * '}' ;
+match_expr : "match" expr '{' match_arm * '}' ;
 
 match_arm : attribute * match_pat "=>" [ expr "," | '{' block '}' ] ;
 
@@ -3563,11 +3563,10 @@ There are four varieties of pointer in Rust:
 
 * Raw pointers (`*`)
   : Raw pointers are pointers without safety or liveness guarantees.
-    Raw pointers are written as `*const T` or `*mut T`,
-    for example `*const int` means a raw pointer to an integer.
-    Copying or dropping a raw pointer has no effect on the lifecycle of any
-    other value.  Dereferencing a raw pointer or converting it to any other
-    pointer type is an [`unsafe` operation](#unsafe-functions).
+    Raw pointers are written `*content`,
+    for example `*int` means a raw pointer to an integer.
+    Copying or dropping a raw pointer has no effect on the lifecycle of any other value.
+    Dereferencing a raw pointer or converting it to any other pointer type is an [`unsafe` operation](#unsafe-functions).
     Raw pointers are generally discouraged in Rust code;
     they exist to support interoperability with foreign code,
     and writing performance-critical or low-level functions.

branches/try2/src/doc/tutorial.md

@@ -2522,7 +2522,7 @@ fn sendable_foo(f: Box<Foo + Send>) { /* ... */ }
 fn shareable_bar<T: Share>(b: &Bar<T> + Share) { /* ... */ }
 ~~~
 
-When no colon is specified (such as the type `Box<Foo>`), it is inferred that the
+When no colon is specified (such as the type `~Foo`), it is inferred that the
 value ascribes to no bounds. They must be added manually if any bounds are
 necessary for usage.
 
@@ -2579,18 +2579,17 @@ fn radius_times_area<T: Circle>(c: T) -> f64 {
 
 Likewise, supertrait methods may also be called on trait objects.
 
-~~~
+~~~ {.ignore}
 use std::f64::consts::PI;
 # trait Shape { fn area(&self) -> f64; }
 # trait Circle : Shape { fn radius(&self) -> f64; }
 # struct Point { x: f64, y: f64 }
 # struct CircleStruct { center: Point, radius: f64 }
 # impl Circle for CircleStruct { fn radius(&self) -> f64 { (self.area() / PI).sqrt() } }
 # impl Shape for CircleStruct { fn area(&self) -> f64 { PI * square(self.radius) } }
-# fn square(x: f64) -> f64 { x * x }
 
-let concrete = box CircleStruct{center:Point{x:3.0,y:4.0},radius:5.0};
-let mycircle: Box<Circle> = concrete as Box<Circle>;
+let concrete = ~CircleStruct{center:Point{x:3.0,y:4.0},radius:5.0};
+let mycircle: ~Circle = concrete as ~Circle;
 let nonsense = mycircle.radius() * mycircle.area();
 ~~~
 

branches/try2/src/etc/2014-06-rewrite-bytes-macros.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/bin/env python
 #
 # Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 # file at the top-level directory of this distribution and at

branches/try2/src/etc/vim/syntax/rust.vim

@@ -30,7 +30,8 @@ syn keyword   rustKeyword     unsafe virtual while
 syn keyword   rustKeyword     use nextgroup=rustModPath skipwhite skipempty
 " FIXME: Scoped impl's name is also fallen in this category
 syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite skipempty
-syn keyword   rustStorage     mut ref static const
+syn keyword   rustStorage     mut ref static
+syn keyword   rustObsoleteStorage const
 
 syn keyword   rustInvalidBareKeyword crate
 

branches/try2/src/liballoc/lib.rs

@@ -69,7 +69,7 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![no_std]
-#![feature(lang_items, phase, unsafe_destructor)]
+#![feature(phase, unsafe_destructor)]
 #![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)]

branches/try2/src/libarena/lib.rs

@@ -30,6 +30,7 @@
 
 #![feature(unsafe_destructor)]
 #![allow(missing_doc)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 use std::cell::{Cell, RefCell};
 use std::cmp;

branches/try2/src/libcollections/lib.rs

@@ -24,6 +24,7 @@
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
 #![feature(unsafe_destructor)]
 #![no_std]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;

branches/try2/src/libcore/lib.rs

@@ -55,10 +55,9 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![no_std]
-#![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
-#![feature(simd, unsafe_destructor)]
+#![feature(globs, macro_rules, managed_boxes, phase, simd, unsafe_destructor)]
 #![deny(missing_doc)]
-#![allow(unknown_features)] // NOTE: remove after stage0 snapshot
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[cfg(test)] extern crate realcore = "core";
 #[cfg(test)] extern crate libc;

branches/try2/src/libnative/lib.rs

@@ -54,14 +54,15 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![deny(unused_result, unused_must_use)]
-#![allow(non_camel_case_types, deprecated)]
+#![allow(non_camel_case_types)]
+#![allow(deprecated)]
 #![allow(unknown_features)] // NOTE: remove after a stage0 snap
-#![feature(default_type_params, lang_items)]
+#![feature(default_type_params)]
 
 // NB this crate explicitly does *not* allow glob imports, please seriously
 //    consider whether they're needed before adding that feature here (the
 //    answer is that you don't need them)
-#![feature(macro_rules, unsafe_destructor, default_type_params)]
+#![feature(macro_rules, unsafe_destructor)]
 
 extern crate alloc;
 extern crate libc;

branches/try2/src/librlibc/lib.rs

@@ -26,8 +26,6 @@
 #![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/")]
-#![feature(intrinsics)]
-#![allow(unknown_features)] // NOTE: remove after stage0 snapshot
 
 #![no_std]
 #![experimental]

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

@@ -20,8 +20,6 @@
 
 use middle::lint;
 
-use syntax::abi::RustIntrinsic;
-use syntax::ast::NodeId;
 use syntax::ast;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
@@ -53,8 +51,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("trace_macros", Active),
     ("concat_idents", Active),
     ("unsafe_destructor", Active),
-    ("intrinsics", Active),
-    ("lang_items", Active),
 
     ("simd", Active),
     ("default_type_params", Active),
@@ -191,18 +187,13 @@ impl<'a> Visitor<()> for Context<'a> {
                 }
             }
 
-            ast::ItemForeignMod(ref foreign_module) => {
+            ast::ItemForeignMod(..) => {
                 if attr::contains_name(i.attrs.as_slice(), "link_args") {
                     self.gate_feature("link_args", i.span,
                                       "the `link_args` attribute is not portable \
                                        across platforms, it is recommended to \
                                        use `#[link(name = \"foo\")]` instead")
                 }
-                if foreign_module.abi == RustIntrinsic {
-                    self.gate_feature("intrinsics",
-                                      i.span,
-                                      "intrinsics are subject to change")
-                }
             }
 
             ast::ItemFn(..) => {
@@ -292,10 +283,14 @@ impl<'a> Visitor<()> for Context<'a> {
     }
 
     fn visit_foreign_item(&mut self, i: &ast::ForeignItem, _: ()) {
-        if attr::contains_name(i.attrs.as_slice(), "linkage") {
-            self.gate_feature("linkage", i.span,
-                              "the `linkage` attribute is experimental \
-                               and not portable across platforms")
+        match i.node {
+            ast::ForeignItemFn(..) | ast::ForeignItemStatic(..) => {
+                if attr::contains_name(i.attrs.as_slice(), "linkage") {
+                    self.gate_feature("linkage", i.span,
+                                      "the `linkage` attribute is experimental \
+                                       and not portable across platforms")
+                }
+            }
         }
         visit::walk_foreign_item(self, i, ())
     }
@@ -343,32 +338,6 @@ impl<'a> Visitor<()> for Context<'a> {
         }
         visit::walk_generics(self, generics, ());
     }
-
-    fn visit_attribute(&mut self, attr: &ast::Attribute, _: ()) {
-        if attr::contains_name([*attr], "lang") {
-            self.gate_feature("lang_items",
-                              attr.span,
-                              "language items are subject to change");
-        }
-    }
-
-    fn visit_fn(&mut self,
-                fn_kind: &visit::FnKind,
-                fn_decl: &ast::FnDecl,
-                block: &ast::Block,
-                span: Span,
-                _: NodeId,
-                (): ()) {
-        match *fn_kind {
-            visit::FkItemFn(_, _, _, ref abi) if *abi == RustIntrinsic => {
-                self.gate_feature("intrinsics",
-                                  span,
-                                  "intrinsics are subject to change")
-            }
-            _ => {}
-        }
-        visit::walk_fn(self, fn_kind, fn_decl, block, span, ());
-    }
 }
 
 pub fn check_crate(sess: &Session, krate: &ast::Crate) {

branches/try2/src/librustc/lib.rs

@@ -29,6 +29,7 @@ This API is completely unstable and subject to change.
       html_root_url = "http://doc.rust-lang.org/")]
 
 #![allow(deprecated)]
+#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 #![feature(macro_rules, globs, struct_variant, managed_boxes, quote)]
 #![feature(default_type_params, phase, unsafe_destructor)]
 

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

@@ -3894,31 +3894,8 @@ impl<'a> Resolver<'a> {
                 self.resolve_error(trait_reference.path.span, msg.as_slice());
             }
             Some(def) => {
-                match def {
-                    (DefTrait(_), _) => {
-                        debug!("(resolving trait) found trait def: {:?}", def);
-                        self.record_def(trait_reference.ref_id, def);
-                    }
-                    (def, _) => {
-                        self.resolve_error(trait_reference.path.span,
-                                           format!("`{}` is not a trait",
-                                                   self.path_idents_to_str(
-                                                        &trait_reference.path)));
-
-                        // If it's a typedef, give a note
-                        match def {
-                            DefTy(_) => {
-                                self.session.span_note(
-                                                trait_reference.path.span,
-                                                format!("`type` aliases cannot \
-                                                        be used for traits")
-                                                        .as_slice());
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-
+                debug!("(resolving trait) found trait def: {:?}", def);
+                self.record_def(trait_reference.ref_id, def);
             }
         }
     }
@@ -4044,9 +4021,6 @@ impl<'a> Resolver<'a> {
 
                 this.with_current_self_type(self_type, |this| {
                     for method in methods.iter() {
-                        // If this is a trait impl, ensure the method exists in trait
-                        this.check_trait_method(&**method);
-
                         // We also need a new scope for the method-specific type parameters.
                         this.resolve_method(MethodRibKind(id, Provided(method.id)),
                                             &**method);
@@ -4056,21 +4030,6 @@ impl<'a> Resolver<'a> {
         });
     }
 
-    fn check_trait_method(&self, method: &Method) {
-        // If there is a TraitRef in scope for an impl, then the method must be in the trait.
-        for &(did, ref trait_ref) in self.current_trait_ref.iter() {
-            let method_name = method.ident.name;
-
-            if self.method_map.borrow().find(&(method_name, did)).is_none() {
-                let path_str = self.path_idents_to_str(&trait_ref.path);
-                self.resolve_error(method.span,
-                                    format!("method `{}` is not a member of trait `{}`",
-                                            token::get_name(method_name),
-                                            path_str).as_slice());
-            }
-        }
-    }
-
     fn resolve_module(&mut self, module: &Mod, _span: Span,
                       _name: Ident, id: NodeId) {
         // Write the implementations in scope into the module metadata.