---

yaml
---
r: 150964
b: refs/heads/try2
c: 80bd176
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 829c00cb09ac093307a6edc5bbca92c4ad9dbda2
+refs/heads/try2: 80bd17643234239ea556e25a8ff56c2164eb6313
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/platform.mk

@@ -542,14 +542,17 @@ ifdef CFG_CCACHE_BASEDIR
   export CCACHE_BASEDIR
 endif
 
+FIND_COMPILER = $(word 1,$(1:ccache=))
+
 define CFG_MAKE_TOOLCHAIN
   # Prepend the tools with their prefix if cross compiling
   ifneq ($(CFG_BUILD),$(1))
 	CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
 	CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
 	CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
 	AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
-	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(CXX_$(1)) -C ar=$$(AR_$(1)) $(RUSTC_CROSS_FLAGS_$(1))
+	RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(CXX_$(1))) \
+	    -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
 
 	RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
   endif

branches/try2/src/compiletest/header.rs

@@ -17,8 +17,6 @@ pub struct TestProps {
     pub error_patterns: Vec<~str> ,
     // Extra flags to pass to the compiler
     pub compile_flags: Option<~str>,
-    // Extra flags to pass when the compiled code is run (such as --bench)
-    pub run_flags: Option<~str>,
     // If present, the name of a file that this test should match when
     // pretty-printed
     pub pp_exact: Option<Path>,
@@ -44,7 +42,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut aux_builds = Vec::new();
     let mut exec_env = Vec::new();
     let mut compile_flags = None;
-    let mut run_flags = None;
     let mut pp_exact = None;
     let mut debugger_cmds = Vec::new();
     let mut check_lines = Vec::new();
@@ -61,10 +58,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             compile_flags = parse_compile_flags(ln);
         }
 
-        if run_flags.is_none() {
-            run_flags = parse_run_flags(ln);
-        }
-
         if pp_exact.is_none() {
             pp_exact = parse_pp_exact(ln, testfile);
         }
@@ -103,11 +96,9 @@ pub fn load_props(testfile: &Path) -> TestProps {
 
         true
     });
-
-    TestProps {
+    return TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
-        run_flags: run_flags,
         pp_exact: pp_exact,
         aux_builds: aux_builds,
         exec_env: exec_env,
@@ -116,7 +107,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         force_host: force_host,
         check_stdout: check_stdout,
         no_prefer_dynamic: no_prefer_dynamic,
-    }
+    };
 }
 
 pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
@@ -169,10 +160,6 @@ fn parse_compile_flags(line: &str) -> Option<~str> {
     parse_name_value_directive(line, "compile-flags".to_owned())
 }
 
-fn parse_run_flags(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, ~"run-flags")
-}
-
 fn parse_debugger_cmd(line: &str) -> Option<~str> {
     parse_name_value_directive(line, "debugger".to_owned())
 }

branches/try2/src/compiletest/runtest.rs

@@ -835,19 +835,14 @@ fn make_exe_name(config: &config, testfile: &Path) -> Path {
     f
 }
 
-fn make_run_args(config: &config, props: &TestProps, testfile: &Path) ->
+fn make_run_args(config: &config, _props: &TestProps, testfile: &Path) ->
    ProcArgs {
     // If we've got another tool to run under (valgrind),
     // then split apart its command
     let mut args = split_maybe_args(&config.runtool);
     let exe_file = make_exe_name(config, testfile);
-
     // FIXME (#9639): This needs to handle non-utf8 paths
     args.push(exe_file.as_str().unwrap().to_owned());
-
-    // Add the arguments in the run_flags directive
-    args.push_all_move(split_maybe_args(&props.run_flags));
-
     let prog = args.shift().unwrap();
     return ProcArgs {prog: prog, args: args};
 }

branches/try2/src/doc/complement-cheatsheet.md

@@ -29,7 +29,7 @@ let x: int = 42;
 let y: ~str = format!("{:t}", x);   // binary
 let y: ~str = format!("{:o}", x);   // octal
 let y: ~str = format!("{:x}", x);   // lowercase hexadecimal
-let y: ~str = format!("{:X}", x);   // uppercase hexadecimal
+let y: ~str = format!("{:X}", x);   // uppercase hexidecimal
 ~~~
 
 **String to int, in non-base-10**

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

@@ -337,7 +337,7 @@ Besides classical synchronization mechanisms like mutexes, one possibility in
 Rust is to use channels (in `std::comm`) to forward data from the C thread
 that invoked the callback into a Rust task.
 
-If an asynchronous callback targets a special object in the Rust address space
+If an asychronous callback targets a special object in the Rust address space
 it is also absolutely necessary that no more callbacks are performed by the
 C library after the respective Rust object gets destroyed.
 This can be achieved by unregistering the callback in the object's

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

@@ -561,7 +561,7 @@ points at a static constant).
 
 Lifetimes can be named and referenced. For example, the special lifetime
 `'static`, which does not go out of scope, can be used to create global
-variables and communicate between tasks (see the manual for use cases).
+variables and communicate between tasks (see the manual for usecases).
 
 ## Parameter Lifetimes
 

branches/try2/src/doc/intro.md

@@ -226,7 +226,7 @@ Now here's the exciting part:
 because `numbers` is an owned type,
 when it is sent across the channel,
 it is actually *moved*,
-transferring ownership of `numbers` between tasks.
+transfering ownership of `numbers` between tasks.
 This ownership transfer is *very fast* -
 in this case simply copying a pointer -
 while also ensuring that the original owning task cannot create data races by continuing to read or write to `numbers` in parallel with the new owner.
@@ -318,7 +318,7 @@ fn main() {
 This is almost exactly the same,
 except that this time `numbers` is first put into an `Arc`.
 `Arc::new` creates the `Arc`,
-`.clone()` makes another `Arc` that refers to the same contents.
+`.clone()` makes another `Arc` that referrs to the same contents.
 So we clone the `Arc` for each task,
 send that clone down the channel,
 and then use it to print out a number.

branches/try2/src/doc/rust.md

@@ -295,7 +295,7 @@ Raw string literals do not process any escapes. They start with the character
 `U+0022` (double-quote) character. The _raw string body_ is not defined in the
 EBNF grammar above: it can contain any sequence of Unicode characters and is
 terminated only by another `U+0022` (double-quote) character, followed by the
-same number of `U+0023` (`#`) characters that preceded the opening `U+0022`
+same number of `U+0023` (`#`) characters that preceeded the opening `U+0022`
 (double-quote) character.
 
 All Unicode characters contained in the raw string body represent themselves,
@@ -1214,22 +1214,6 @@ struct Cookie;
 let c = [Cookie, Cookie, Cookie, Cookie];
 ~~~~
 
-By using the `struct_inherit` feature gate, structures may use single inheritance. A Structure may only
-inherit from a single other structure, called the _super-struct_. The inheriting structure (sub-struct)
-acts as if all fields in the super-struct were present in the sub-struct. Fields declared in a sub-struct
-must not have the same name as any field in any (transitive) super-struct. All fields (both declared
-and inherited) must be specified in any initializers. Inheritance between structures does not give
-subtyping or coercion. The super-struct and sub-struct must be defined in the same crate. The super-struct
-must be declared using the `virtual` keyword.
-For example:
-
-~~~~ {.ignore}
-virtual struct Sup { x: int }
-struct Sub : Sup { y: int }
-let s = Sub {x: 10, y: 11};
-let sx = s.x;
-~~~~
-
 ### Enumerations
 
 An _enumeration_ is a simultaneous definition of a nominal [enumerated type](#enumerated-types) as well as a set of *constructors*,
@@ -2256,7 +2240,7 @@ fn main() {
 Certain aspects of Rust may be implemented in the compiler, but they're not
 necessarily ready for every-day use. These features are often of "prototype
 quality" or "almost production ready", but may not be stable enough to be
-considered a full-fledged language feature.
+considered a full-fleged language feature.
 
 For this reason, Rust recognizes a special crate-level attribute of the form:
 
@@ -4005,7 +3989,7 @@ dependencies will be used:
    could only be found in an `rlib` format. Remember that `staticlib` formats
    are always ignored by `rustc` for crate-linking purposes.
 
-2. If a static library is being produced, all upstream dependencies are
+2. If a static library is being produced, all upstream dependecies are
    required to be available in `rlib` formats. This requirement stems from the
    same reasons that a dynamic library must have all dynamic dependencies.
 

branches/try2/src/doc/tutorial.md

@@ -1883,8 +1883,8 @@ impl Shape {
 
 let s = Circle(Point { x: 1.0, y: 2.0 }, 3.0);
 
-(&s).draw_reference();
 (~s).draw_owned();
+(&s).draw_reference();
 s.draw_value();
 ~~~
 

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

@@ -151,8 +151,6 @@ fn fold_struct(cx: &Context, def: &ast::StructDef) -> @ast::StructDef {
     @ast::StructDef {
         fields: fields.collect(),
         ctor_id: def.ctor_id,
-        super_struct: def.super_struct.clone(),
-        is_virtual: def.is_virtual,
     }
 }
 

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

@@ -16,7 +16,7 @@
 //! enabled.
 //!
 //! Features are enabled in programs via the crate-level attributes of
-//! #![feature(...)] with a comma-separated list of features.
+//! #[feature(...)] with a comma-separated list of features.
 
 use middle::lint;
 
@@ -55,7 +55,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("default_type_params", Active),
     ("quote", Active),
     ("linkage", Active),
-    ("struct_inherit", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -191,22 +190,11 @@ impl<'a> Visitor<()> for Context<'a> {
                 }
             }
 
-            ast::ItemStruct(struct_definition, _) => {
+            ast::ItemStruct(..) => {
                 if attr::contains_name(i.attrs.as_slice(), "simd") {
                     self.gate_feature("simd", i.span,
                                       "SIMD types are experimental and possibly buggy");
                 }
-                match struct_definition.super_struct {
-                    Some(ref path) => self.gate_feature("struct_inherit", path.span,
-                                                        "struct inheritance is experimental \
-                                                         and possibly buggy"),
-                    None => {}
-                }
-                if struct_definition.is_virtual {
-                    self.gate_feature("struct_inherit", i.span,
-                                      "struct inheritance (`virtual` keyword) is \
-                                       experimental and possibly buggy");
-                }
             }
 
             _ => {}
@@ -324,7 +312,7 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
         match attr.meta_item_list() {
             None => {
                 sess.span_err(attr.span, "malformed feature attribute, \
-                                          expected #![feature(...)]");
+                                          expected #[feature(...)]");
             }
             Some(list) => {
                 for &mi in list.iter() {

branches/try2/src/librustc/lib/llvm.rs

@@ -709,7 +709,6 @@ pub mod llvm {
         pub fn LLVMSetGC(Fn: ValueRef, Name: *c_char);
         pub fn LLVMAddFunctionAttr(Fn: ValueRef, PA: c_uint);
         pub fn LLVMAddFunctionAttrString(Fn: ValueRef, Name: *c_char);
-        pub fn LLVMRemoveFunctionAttrString(Fn: ValueRef, Name: *c_char);
         pub fn LLVMGetFunctionAttr(Fn: ValueRef) -> c_ulonglong;
 
         pub fn LLVMAddReturnAttribute(Fn: ValueRef, PA: c_uint);