---

yaml
---
r: 44324
b: refs/heads/snap-stage3
c: 93a7f23
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 3e6b2cfab5b838138f2bec5c696089b7f5005361
+refs/heads/snap-stage3: 93a7f237d78bf84494ed158a43e4aeae9966dd7c
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/configure

@@ -678,7 +678,7 @@ do
         LLVM_BUILD_DIR=${CFG_BUILD_DIR}llvm/$t
         if [ ! -z "$CFG_DISABLE_OPTIMIZE_LLVM" ]
         then
-            LLVM_DBG_OPTS="--enable-debug-symbols --disable-optimized"
+            LLVM_DBG_OPTS=""
             # Just use LLVM straight from its build directory to
             # avoid 'make install' time
             LLVM_INST_DIR=$LLVM_BUILD_DIR/Debug+Asserts

branches/snap-stage3/doc/rust.md

@@ -1611,7 +1611,6 @@ The following are examples of structure expressions:
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
 # mod game { pub struct User { name: &str, age: uint, score: uint } }
-# use game;
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
 let u = game::User {name: "Joe", age: 35u, score: 100_000};

branches/snap-stage3/doc/tutorial-tasks.md

@@ -468,7 +468,6 @@ Here is the function that implements the child task:
 
 ~~~~
 # use std::comm::DuplexStream;
-# use comm::{Port, Chan};
 fn stringifier(channel: &DuplexStream<~str, uint>) {
     let mut value: uint;
     loop {
@@ -491,7 +490,6 @@ Here is the code for the parent task:
 
 ~~~~
 # use std::comm::DuplexStream;
-# use comm::{Port, Chan};
 # use task::spawn;
 # fn stringifier(channel: &DuplexStream<~str, uint>) {
 #     let mut value: uint;

branches/snap-stage3/doc/tutorial.md

@@ -2270,7 +2270,9 @@ fn chicken_farmer() {
     // The same, but name it `my_chicken`
     use my_chicken = farm::chicken;
     ...
+# my_chicken();
 }
+# chicken();
 # }
 ~~~
 

branches/snap-stage3/src/libcore/os.rs

@@ -566,17 +566,13 @@ pub fn path_exists(p: &Path) -> bool {
  *
  * If the given path is relative, return it prepended with the current working
  * directory. If the given path is already an absolute path, return it
- * as is.
+ * as is.  This is a shortcut for calling os::getcwd().unsafe_join(p)
  */
 // NB: this is here rather than in path because it is a form of environment
 // querying; what it does depends on the process working directory, not just
 // the input paths.
 pub fn make_absolute(p: &Path) -> Path {
-    if p.is_absolute {
-        copy *p
-    } else {
-        getcwd().push_many(p.components)
-    }
+    getcwd().unsafe_join(p)
 }
 
 

branches/snap-stage3/src/libcore/path.rs

@@ -64,6 +64,9 @@ pub trait GenericPath {
     pure fn push_many((&[~str])) -> Self;
     pure fn pop() -> Self;
 
+    pure fn unsafe_join((&Self)) -> Self;
+    pure fn is_restricted() -> bool;
+
     pure fn normalize() -> Self;
 }
 
@@ -485,6 +488,19 @@ impl GenericPath for PosixPath {
         self.push_many(other.components)
     }
 
+    pure fn unsafe_join(other: &PosixPath) -> PosixPath {
+        if other.is_absolute {
+            PosixPath { is_absolute: true,
+                        components: copy other.components }
+        } else {
+            self.push_rel(other)
+        }
+    }
+
+    pure fn is_restricted() -> bool {
+        false
+    }
+
     pure fn push_many(cs: &[~str]) -> PosixPath {
         let mut v = copy self.components;
         for cs.each |e| {
@@ -685,6 +701,61 @@ impl GenericPath for WindowsPath {
         self.push_many(other.components)
     }
 
+    pure fn unsafe_join(other: &WindowsPath) -> WindowsPath {
+        /* rhs not absolute is simple push */
+        if !other.is_absolute {
+            return self.push_many(other.components);
+        }
+
+        /* if rhs has a host set, then the whole thing wins */
+        match other.host {
+            Some(copy host) => {
+                return WindowsPath {
+                    host: Some(host),
+                    device: copy other.device,
+                    is_absolute: true,
+                    components: copy other.components
+                };
+            }
+            _ => {}
+        }
+
+        /* if rhs has a device set, then a part wins */
+        match other.device {
+            Some(copy device) => {
+                return WindowsPath {
+                    host: None,
+                    device: Some(device),
+                    is_absolute: true,
+                    components: copy other.components
+                };
+            }
+            _ => {}
+        }
+
+        /* fallback: host and device of lhs win, but the
+           whole path of the right */
+        WindowsPath {
+            host: copy self.host,
+            device: copy self.device,
+            is_absolute: self.is_absolute || other.is_absolute,
+            components: copy other.components
+        }
+    }
+
+    pure fn is_restricted() -> bool {
+        match self.filestem() {
+            Some(stem) => {
+                match stem.to_lower() {
+                    ~"con" | ~"aux" | ~"com1" | ~"com2" | ~"com3" | ~"com4" |
+                    ~"lpt1" | ~"lpt2" | ~"lpt3" | ~"prn" | ~"nul" => true,
+                    _ => false
+                }
+            },
+            None => false
+        }
+    }
+
     pure fn push_many(cs: &[~str]) -> WindowsPath {
         let mut v = copy self.components;
         for cs.each |e| {
@@ -725,7 +796,10 @@ impl GenericPath for WindowsPath {
     pure fn normalize() -> WindowsPath {
         return WindowsPath {
             host: copy self.host,
-            device: copy self.device,
+            device: match self.device {
+                None => None,
+                Some(ref device) => Some(device.to_upper())
+            },
             is_absolute: self.is_absolute,
             components: normalize(self.components)
         }
@@ -764,13 +838,13 @@ pub mod windows {
 
     pub pure fn extract_unc_prefix(s: &str) -> Option<(~str,~str)> {
         if (s.len() > 1 &&
-            s[0] == '\\' as u8 &&
-            s[1] == '\\' as u8) {
+            (s[0] == '\\' as u8 || s[0] == '/' as u8) &&
+            s[0] == s[1]) {
             let mut i = 2;
             while i < s.len() {
-                if s[i] == '\\' as u8 {
+                if is_sep(s[i]) {
                     let pre = s.slice(2, i);
-                    let rest = s.slice(i, s.len());
+                    let mut rest = s.slice(i, s.len());
                     return Some((pre, rest));
                 }
                 i += 1;
@@ -916,13 +990,21 @@ mod tests {
     #[test]
     fn test_extract_unc_prefixes() {
         assert windows::extract_unc_prefix("\\\\").is_none();
+        assert windows::extract_unc_prefix("//").is_none();
         assert windows::extract_unc_prefix("\\\\hi").is_none();
+        assert windows::extract_unc_prefix("//hi").is_none();
         assert windows::extract_unc_prefix("\\\\hi\\") ==
             Some((~"hi", ~"\\"));
+        assert windows::extract_unc_prefix("//hi\\") ==
+            Some((~"hi", ~"\\"));
         assert windows::extract_unc_prefix("\\\\hi\\there") ==
             Some((~"hi", ~"\\there"));
+        assert windows::extract_unc_prefix("//hi/there") ==
+            Some((~"hi", ~"/there"));
         assert windows::extract_unc_prefix("\\\\hi\\there\\friends.txt") ==
             Some((~"hi", ~"\\there\\friends.txt"));
+        assert windows::extract_unc_prefix("//hi\\there\\friends.txt") ==
+            Some((~"hi", ~"\\there\\friends.txt"));
     }
 
     #[test]
@@ -981,5 +1063,61 @@ mod tests {
             .push_many([~"lib", ~"thingy.dll"])
             .with_filename("librustc.dll")),
           "c:\\program files (x86)\\rust\\lib\\librustc.dll");
+
+        t(&(WindowsPath("\\\\computer\\share")
+            .unsafe_join(&WindowsPath("\\a"))),
+          "\\\\computer\\a");
+
+        t(&(WindowsPath("//computer/share")
+            .unsafe_join(&WindowsPath("\\a"))),
+          "\\\\computer\\a");
+
+        t(&(WindowsPath("//computer/share")
+            .unsafe_join(&WindowsPath("\\\\computer\\share"))),
+          "\\\\computer\\share");
+
+        t(&(WindowsPath("C:/whatever")
+            .unsafe_join(&WindowsPath("//computer/share/a/b"))),
+          "\\\\computer\\share\\a\\b");
+
+        t(&(WindowsPath("C:")
+            .unsafe_join(&WindowsPath("D:/foo"))),
+          "D:\\foo");
+
+        t(&(WindowsPath("C:")
+            .unsafe_join(&WindowsPath("B"))),
+          "C:B");
+
+        t(&(WindowsPath("C:")
+            .unsafe_join(&WindowsPath("/foo"))),
+          "C:\\foo");
+
+        t(&(WindowsPath("C:\\")
+            .unsafe_join(&WindowsPath("\\bar"))),
+          "C:\\bar");
+
+        t(&(WindowsPath("")
+            .unsafe_join(&WindowsPath(""))),
+          "");
+
+        t(&(WindowsPath("")
+            .unsafe_join(&WindowsPath("a"))),
+          "a");
+
+        t(&(WindowsPath("")
+            .unsafe_join(&WindowsPath("C:\\a"))),
+          "C:\\a");
+
+        t(&(WindowsPath("c:\\foo")
+            .normalize()),
+          "C:\\foo");
+    }
+
+    #[test]
+    fn test_windows_path_restrictions() {
+        assert WindowsPath("hi").is_restricted() == false;
+        assert WindowsPath("C:\\NUL").is_restricted() == true;
+        assert WindowsPath("C:\\COM1.TXT").is_restricted() == true;
+        assert WindowsPath("c:\\prn.exe").is_restricted() == true;
     }
 }

branches/snap-stage3/src/librustc/middle/resolve.rs

@@ -19,6 +19,7 @@ use metadata::cstore::find_extern_mod_stmt_cnum;
 use metadata::decoder::{def_like, dl_def, dl_field, dl_impl};
 use middle::lang_items::LanguageItems;
 use middle::lint::{deny, allow, forbid, level, unused_imports, warn};
+use middle::lint::{get_lint_level, get_lint_settings_level};
 use middle::pat_util::{pat_bindings};
 
 use core::cmp;
@@ -508,16 +509,6 @@ pub impl Module {
     }
 }
 
-pub fn unused_import_lint_level(session: Session) -> level {
-    for session.opts.lint_opts.each |lint_option_pair| {
-        let (lint_type, lint_level) = *lint_option_pair;
-        if lint_type == unused_imports {
-            return lint_level;
-        }
-    }
-    return allow;
-}
-
 // Records a possibly-private type definition.
 pub struct TypeNsDef {
     privacy: Privacy,
@@ -770,8 +761,6 @@ pub fn Resolver(session: Session,
 
         graph_root: graph_root,
 
-        unused_import_lint_level: unused_import_lint_level(session),
-
         trait_info: @HashMap(),
         structs: @HashMap(),
 
@@ -816,8 +805,6 @@ pub struct Resolver {
 
     graph_root: @mut NameBindings,
 
-    unused_import_lint_level: level,
-
     trait_info: @HashMap<def_id,@HashMap<ident,()>>,
     structs: @HashMap<def_id,()>,
 
@@ -5232,8 +5219,17 @@ pub impl Resolver {
     // resolve data structures.
     //
 
+    fn unused_import_lint_level(@mut self, m: @mut Module) -> level {
+        let settings = self.session.lint_settings;
+        match m.def_id {
+            Some(def) => get_lint_settings_level(settings, unused_imports,
+                                                 def.node, def.node),
+            None => get_lint_level(settings.default_settings, unused_imports)
+        }
+    }
+
     fn check_for_unused_imports_if_necessary(@mut self) {
-        if self.unused_import_lint_level == allow {
+        if self.unused_import_lint_level(self.current_module) == allow {
             return;
         }
 
@@ -5285,12 +5281,15 @@ pub impl Resolver {
         for module_.import_resolutions.each_value |&import_resolution| {
             // Ignore dummy spans for things like automatically injected
             // imports for the prelude, and also don't warn about the same
-            // import statement being unused more than once.
+            // import statement being unused more than once. Furthermore, if
+            // the import is public, then we can't be sure whether it's unused
+            // or not so don't warn about it.
             if !import_resolution.state.used &&
                     !import_resolution.state.warned &&
-                    import_resolution.span != dummy_sp() {
+                    import_resolution.span != dummy_sp() &&
+                    import_resolution.privacy != Public {
                 import_resolution.state.warned = true;
-                match self.unused_import_lint_level {
+                match self.unused_import_lint_level(module_) {
                     warn => {
                         self.session.span_warn(copy import_resolution.span,
                                                ~"unused import");
@@ -5299,11 +5298,7 @@ pub impl Resolver {
                       self.session.span_err(copy import_resolution.span,
                                             ~"unused import");
                     }
-                    allow => {
-                      self.session.span_bug(copy import_resolution.span,
-                                            ~"shouldn't be here if lint \
-                                              is allowed");
-                    }
+                    allow => ()
                 }
             }
         }