---

yaml
---
r: 149821
b: refs/heads/try2
c: 71cab04
h: refs/heads/master
i:
  149819: 52789cd
v: v3

Author: sfackler

[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: 5d1d285623f8d454a62ca16cf8ec2533aad23305
+refs/heads/try2: 71cab0410f411c78dfe297bec5d35ad5a9e09d35
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rustdoc.md

@@ -117,15 +117,24 @@ code block.
     // This is a testable code block (4-space indent)
 ~~~
 
-In addition to the `ignore` directive, you can specify that the test's execution
-should fail with the `should_fail` directive.
+You can specify that the test's execution should fail with the `should_fail`
+directive.
 
 ~~~
 ```should_fail
 // This code block is expected to generate a failure when run
 ```
 ~~~
 
+You can specify that the code block should be compiled but not run with the
+`no_run` directive.
+
+~~~
+```no_run
+// This code will be compiled but not executed
+```
+~~~
+
 Rustdoc also supplies some extra sugar for helping with some tedious
 documentation examples. If a line is prefixed with `# `, then the line
 will not show up in the HTML documentation, but it will be used when

branches/try2/src/librustc/metadata/loader.rs

@@ -299,17 +299,17 @@ impl<'a> Context<'a> {
 
         let lib = m.move_iter().next().unwrap();
         if slot.is_none() {
-            info!("{} reading metadata from: {}", flavor, lib.display());
+            info!("{} reading meatadata from: {}", flavor, lib.display());
             match get_metadata_section(self.os, &lib) {
-                Ok(blob) => {
+                Some(blob) => {
                     if self.crate_matches(blob.as_slice()) {
                         *slot = Some(blob);
                     } else {
                         info!("metadata mismatch");
                         return None;
                     }
                 }
-                Err(_) => {
+                None => {
                     info!("no metadata found");
                     return None
                 }
@@ -388,18 +388,15 @@ impl ArchiveMetadata {
 }
 
 // Just a small wrapper to time how long reading metadata takes.
-fn get_metadata_section(os: Os, filename: &Path) -> Result<MetadataBlob, ~str> {
+fn get_metadata_section(os: Os, filename: &Path) -> Option<MetadataBlob> {
     let start = time::precise_time_ns();
     let ret = get_metadata_section_imp(os, filename);
     info!("reading {} => {}ms", filename.filename_display(),
            (time::precise_time_ns() - start) / 1000000);
     return ret;
 }
 
-fn get_metadata_section_imp(os: Os, filename: &Path) -> Result<MetadataBlob, ~str> {
-    if !filename.exists() {
-        return Err(format!("no such file: '{}'", filename.display()));
-    }
+fn get_metadata_section_imp(os: Os, filename: &Path) -> Option<MetadataBlob> {
     if filename.filename_str().unwrap().ends_with(".rlib") {
         // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap
         // internally to read the file. We also avoid even using a memcpy by
@@ -408,26 +405,19 @@ fn get_metadata_section_imp(os: Os, filename: &Path) -> Result<MetadataBlob, ~st
             Some(ar) => ar,
             None => {
                 debug!("llvm didn't like `{}`", filename.display());
-                return Err(format!("failed to read rlib metadata: '{}'",
-                                   filename.display()));
+                return None;
             }
         };
-        return match ArchiveMetadata::new(archive).map(|ar| MetadataArchive(ar)) {
-            None => return Err(format!("failed to read rlib metadata: '{}'",
-                                       filename.display())),
-            Some(blob) => return Ok(blob)
-        }
+        return ArchiveMetadata::new(archive).map(|ar| MetadataArchive(ar));
     }
     unsafe {
         let mb = filename.with_c_str(|buf| {
             llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
         });
-        if mb as int == 0 {
-            return Err(format!("error reading library: '{}'",filename.display()))
-        }
+        if mb as int == 0 { return None }
         let of = match ObjectFile::new(mb) {
             Some(of) => of,
-            _ => return Err(format!("provided path not an object file: '{}'", filename.display()))
+            _ => return None
         };
         let si = mk_section_iter(of.llof);
         while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
@@ -437,31 +427,30 @@ fn get_metadata_section_imp(os: Os, filename: &Path) -> Result<MetadataBlob, ~st
             if read_meta_section_name(os) == name {
                 let cbuf = llvm::LLVMGetSectionContents(si.llsi);
                 let csz = llvm::LLVMGetSectionSize(si.llsi) as uint;
-                let mut found = Err(format!("metadata not found: '{}'", filename.display()));
+                let mut found = None;
                 let cvbuf: *u8 = cast::transmute(cbuf);
                 let vlen = encoder::metadata_encoding_version.len();
                 debug!("checking {} bytes of metadata-version stamp",
                        vlen);
                 let minsz = cmp::min(vlen, csz);
                 let version_ok = vec::raw::buf_as_slice(cvbuf, minsz,
                     |buf0| buf0 == encoder::metadata_encoding_version);
-                if !version_ok { return Err(format!("incompatible metadata version found: '{}'",
-                                                    filename.display()));}
+                if !version_ok { return None; }
 
                 let cvbuf1 = cvbuf.offset(vlen as int);
                 debug!("inflating {} bytes of compressed metadata",
                        csz - vlen);
                 vec::raw::buf_as_slice(cvbuf1, csz-vlen, |bytes| {
                     let inflated = flate::inflate_bytes(bytes);
-                    found = Ok(MetadataVec(inflated));
+                    found = Some(MetadataVec(inflated));
                 });
-                if found.is_ok() {
+                if found.is_some() {
                     return found;
                 }
             }
             llvm::LLVMMoveToNextSection(si.llsi);
         }
-        return Err(format!("metadata not found: '{}'", filename.display()));
+        return None;
     }
 }
 
@@ -489,9 +478,9 @@ pub fn read_meta_section_name(os: Os) -> &'static str {
 pub fn list_file_metadata(os: Os, path: &Path,
                           out: &mut io::Writer) -> io::IoResult<()> {
     match get_metadata_section(os, path) {
-        Ok(bytes) => decoder::list_crate_metadata(bytes.as_slice(), out),
-        Err(msg) => {
-            write!(out, "{}\n", msg)
+        Some(bytes) => decoder::list_crate_metadata(bytes.as_slice(), out),
+        None => {
+            write!(out, "could not find metadata in {}.\n", path.display())
         }
     }
 }

branches/try2/src/librustdoc/html/markdown.rs

@@ -245,14 +245,15 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
     extern fn block(_ob: *buf, text: *buf, lang: *buf, opaque: *libc::c_void) {
         unsafe {
             if text.is_null() { return }
-            let (shouldfail, ignore) = if lang.is_null() {
-                (false, false)
+            let (should_fail, no_run, ignore) = if lang.is_null() {
+                (false, false, false)
             } else {
                 vec::raw::buf_as_slice((*lang).data,
                                        (*lang).size as uint, |lang| {
                     let s = str::from_utf8(lang).unwrap();
-                    (s.contains("should_fail"), s.contains("ignore") ||
-                                                s.contains("notrust"))
+                    (s.contains("should_fail"),
+                     s.contains("no_run"),
+                     s.contains("ignore") || s.contains("notrust"))
                 })
             };
             if ignore { return }
@@ -261,7 +262,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
                 let text = str::from_utf8(text).unwrap();
                 let mut lines = text.lines().map(|l| stripped_filtered_line(l).unwrap_or(l));
                 let text = lines.to_owned_vec().connect("\n");
-                tests.add_test(text, shouldfail);
+                tests.add_test(text, should_fail, no_run);
             })
         }
     }

branches/try2/src/librustdoc/test.rs

@@ -98,7 +98,8 @@ pub fn run(input: &str, matches: &getopts::Matches) -> int {
     0
 }
 
-fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool) {
+fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool,
+           no_run: bool) {
     let test = maketest(test, cratename);
     let parsesess = parse::new_parse_sess();
     let input = driver::StrInput(test);
@@ -152,6 +153,8 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool)
     let cfg = driver::build_configuration(sess);
     driver::compile_input(sess, cfg, &input, &out, &None);
 
+    if no_run { return }
+
     // Run the code!
     let exe = outdir.path().join("rust_out");
     let out = Process::output(exe.as_str().unwrap(), []);
@@ -203,7 +206,7 @@ pub struct Collector {
 }
 
 impl Collector {
-    pub fn add_test(&mut self, test: &str, should_fail: bool) {
+    pub fn add_test(&mut self, test: &str, should_fail: bool, no_run: bool) {
         let test = test.to_owned();
         let name = format!("{}_{}", self.names.connect("::"), self.cnt);
         self.cnt += 1;
@@ -218,7 +221,7 @@ impl Collector {
                 should_fail: false, // compiler failures are test failures
             },
             testfn: testing::DynTestFn(proc() {
-                runtest(test, cratename, libs, should_fail);
+                runtest(test, cratename, libs, should_fail, no_run);
             }),
         });
     }

branches/try2/src/libstd/cell.rs

@@ -11,7 +11,7 @@
 //! Types dealing with dynamic mutability
 
 use cast;
-use clone::Clone;
+use clone::{Clone, DeepClone};
 use cmp::Eq;
 use fmt;
 use kinds::{marker, Pod};
@@ -222,6 +222,13 @@ impl<T: Clone> Clone for RefCell<T> {
     }
 }
 
+impl<T: DeepClone> DeepClone for RefCell<T> {
+    fn deep_clone(&self) -> RefCell<T> {
+        let x = self.borrow();
+        RefCell::new(x.get().deep_clone())
+    }
+}
+
 impl<T: Eq> Eq for RefCell<T> {
     fn eq(&self, other: &RefCell<T>) -> bool {
         let a = self.borrow();