rollup merge of #20721: japaric/snap
Conflicts: src/libcollections/vec.rs src/libcore/fmt/mod.rs src/librustc/lint/builtin.rs src/librustc/session/config.rs src/librustc_trans/trans/base.rs src/librustc_trans/trans/context.rs src/librustc_trans/trans/type_.rs src/librustc_typeck/check/_match.rs src/librustdoc/html/format.rs src/libsyntax/std_inject.rs src/libsyntax/util/interner.rs src/test/compile-fail/mut-pattern-mismatched.rs
This commit is contained in:
Alex Crichton
commit
6e806bdefd
236 changed files with 2421 additions and 2495 deletions
|
|
@ -68,7 +68,7 @@ use fmt;
|
|||
use iter::IteratorExt;
|
||||
use option::Option;
|
||||
use option::Option::{None, Some};
|
||||
use ops::{FullRange, Index};
|
||||
use ops::FullRange;
|
||||
use str;
|
||||
use str::StrExt;
|
||||
use string::{String, CowString};
|
||||
|
|
@ -352,7 +352,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
match name.rposition_elem(&dot) {
|
||||
None | Some(0) => name,
|
||||
Some(1) if name == b".." => name,
|
||||
Some(pos) => name.index(&(0..pos))
|
||||
Some(pos) => &name[0..pos]
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
@ -399,7 +399,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
match name.rposition_elem(&dot) {
|
||||
None | Some(0) => None,
|
||||
Some(1) if name == b".." => None,
|
||||
Some(pos) => Some(name.index(&((pos+1)..)))
|
||||
Some(pos) => Some(&name[(pos+1)..])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -475,7 +475,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
let extlen = extension.container_as_bytes().len();
|
||||
match (name.rposition_elem(&dot), extlen) {
|
||||
(None, 0) | (Some(0), 0) => None,
|
||||
(Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()),
|
||||
(Some(idx), 0) => Some(name[0..idx].to_vec()),
|
||||
(idx, extlen) => {
|
||||
let idx = match idx {
|
||||
None | Some(0) => name.len(),
|
||||
|
|
@ -484,7 +484,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
|
|||
|
||||
let mut v;
|
||||
v = Vec::with_capacity(idx + extlen + 1);
|
||||
v.push_all(name.index(&(0..idx)));
|
||||
v.push_all(&name[0..idx]);
|
||||
v.push(dot);
|
||||
v.push_all(extension.container_as_bytes());
|
||||
Some(v)
|
||||
|
|
@ -876,7 +876,7 @@ impl BytesContainer for String {
|
|||
}
|
||||
#[inline]
|
||||
fn container_as_str(&self) -> Option<&str> {
|
||||
Some(self.index(&FullRange))
|
||||
Some(&self[])
|
||||
}
|
||||
#[inline]
|
||||
fn is_str(_: Option<&String>) -> bool { true }
|
||||
|
|
@ -892,7 +892,7 @@ impl BytesContainer for [u8] {
|
|||
impl BytesContainer for Vec<u8> {
|
||||
#[inline]
|
||||
fn container_as_bytes(&self) -> &[u8] {
|
||||
self.index(&FullRange)
|
||||
&self[]
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@ use hash;
|
|||
use io::Writer;
|
||||
use iter::{AdditiveIterator, Extend};
|
||||
use iter::{Iterator, IteratorExt, Map};
|
||||
use ops::Index;
|
||||
use marker::Sized;
|
||||
use option::Option::{self, Some, None};
|
||||
use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
|
||||
|
|
@ -127,7 +126,7 @@ impl GenericPathUnsafe for Path {
|
|||
None => {
|
||||
self.repr = Path::normalize(filename);
|
||||
}
|
||||
Some(idx) if self.repr.index(&((idx+1)..)) == b".." => {
|
||||
Some(idx) if &self.repr[(idx+1)..] == b".." => {
|
||||
let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
|
||||
v.push_all(self.repr.as_slice());
|
||||
v.push(SEP_BYTE);
|
||||
|
|
@ -137,7 +136,7 @@ impl GenericPathUnsafe for Path {
|
|||
}
|
||||
Some(idx) => {
|
||||
let mut v = Vec::with_capacity(idx + 1 + filename.len());
|
||||
v.push_all(self.repr.index(&(0..(idx+1))));
|
||||
v.push_all(&self.repr[0..(idx+1)]);
|
||||
v.push_all(filename);
|
||||
// FIXME: this is slow
|
||||
self.repr = Path::normalize(v.as_slice());
|
||||
|
|
@ -178,9 +177,9 @@ impl GenericPath for Path {
|
|||
match self.sepidx {
|
||||
None if b".." == self.repr => self.repr.as_slice(),
|
||||
None => dot_static,
|
||||
Some(0) => self.repr.index(&(0..1)),
|
||||
Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(),
|
||||
Some(idx) => self.repr.index(&(0..idx))
|
||||
Some(0) => &self.repr[0..1],
|
||||
Some(idx) if &self.repr[(idx+1)..] == b".." => self.repr.as_slice(),
|
||||
Some(idx) => &self.repr[0..idx]
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -189,9 +188,9 @@ impl GenericPath for Path {
|
|||
None if b"." == self.repr ||
|
||||
b".." == self.repr => None,
|
||||
None => Some(self.repr.as_slice()),
|
||||
Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None,
|
||||
Some(0) if self.repr.index(&(1..)).is_empty() => None,
|
||||
Some(idx) => Some(self.repr.index(&((idx+1)..)))
|
||||
Some(idx) if &self.repr[(idx+1)..] == b".." => None,
|
||||
Some(0) if self.repr[1..].is_empty() => None,
|
||||
Some(idx) => Some(&self.repr[(idx+1)..])
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -333,7 +332,7 @@ impl Path {
|
|||
// borrowck is being very picky
|
||||
let val = {
|
||||
let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
|
||||
let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() };
|
||||
let v_ = if is_abs { &v.as_slice()[1..] } else { v.as_slice() };
|
||||
let comps = normalize_helper(v_, is_abs);
|
||||
match comps {
|
||||
None => None,
|
||||
|
|
@ -372,7 +371,7 @@ impl Path {
|
|||
/// A path of "/" yields no components. A path of "." yields one component.
|
||||
pub fn components<'a>(&'a self) -> Components<'a> {
|
||||
let v = if self.repr[0] == SEP_BYTE {
|
||||
self.repr.index(&(1..))
|
||||
&self.repr[1..]
|
||||
} else { self.repr.as_slice() };
|
||||
let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr
|
||||
let mut ret = v.split(is_sep_byte);
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ use iter::{AdditiveIterator, Extend};
|
|||
use iter::{Iterator, IteratorExt, Map, repeat};
|
||||
use mem;
|
||||
use option::Option::{self, Some, None};
|
||||
use ops::{FullRange, Index};
|
||||
use ops::FullRange;
|
||||
use slice::{SliceExt, SliceConcatExt};
|
||||
use str::{SplitTerminator, FromStr, StrExt};
|
||||
use string::{String, ToString};
|
||||
|
|
@ -173,30 +173,30 @@ impl GenericPathUnsafe for Path {
|
|||
s.push_str("..");
|
||||
s.push(SEP);
|
||||
s.push_str(filename);
|
||||
self.update_normalized(s.index(&FullRange));
|
||||
self.update_normalized(&s[]);
|
||||
}
|
||||
None => {
|
||||
self.update_normalized(filename);
|
||||
}
|
||||
Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
|
||||
Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
|
||||
let mut s = String::with_capacity(end + 1 + filename.len());
|
||||
s.push_str(self.repr.index(&(0..end)));
|
||||
s.push_str(&self.repr[0..end]);
|
||||
s.push(SEP);
|
||||
s.push_str(filename);
|
||||
self.update_normalized(s.index(&FullRange));
|
||||
self.update_normalized(&s[]);
|
||||
}
|
||||
Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
|
||||
let mut s = String::with_capacity(idxb + filename.len());
|
||||
s.push_str(self.repr.index(&(0..idxb)));
|
||||
s.push_str(&self.repr[0..idxb]);
|
||||
s.push_str(filename);
|
||||
self.update_normalized(s.index(&FullRange));
|
||||
self.update_normalized(&s[]);
|
||||
}
|
||||
Some((idxb,_,_)) => {
|
||||
let mut s = String::with_capacity(idxb + 1 + filename.len());
|
||||
s.push_str(self.repr.index(&(0..idxb)));
|
||||
s.push_str(&self.repr[0..idxb]);
|
||||
s.push(SEP);
|
||||
s.push_str(filename);
|
||||
self.update_normalized(s.index(&FullRange));
|
||||
self.update_normalized(&s[]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -215,12 +215,12 @@ impl GenericPathUnsafe for Path {
|
|||
let path = path.container_as_str().unwrap();
|
||||
fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool {
|
||||
// assume prefix is Some(DiskPrefix)
|
||||
let rest = path.index(&(prefix_len(prefix)..));
|
||||
let rest = &path[prefix_len(prefix)..];
|
||||
!rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char)
|
||||
}
|
||||
fn shares_volume(me: &Path, path: &str) -> bool {
|
||||
// path is assumed to have a prefix of Some(DiskPrefix)
|
||||
let repr = me.repr.index(&FullRange);
|
||||
let repr = &me.repr[];
|
||||
match me.prefix {
|
||||
Some(DiskPrefix) => {
|
||||
repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
|
||||
|
|
@ -252,7 +252,7 @@ impl GenericPathUnsafe for Path {
|
|||
else { None };
|
||||
let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
|
||||
let mut s = String::with_capacity(me.repr.len() + 1 + pathlen);
|
||||
s.push_str(me.repr.index(&FullRange));
|
||||
s.push_str(&me.repr[]);
|
||||
let plen = me.prefix_len();
|
||||
// if me is "C:" we don't want to add a path separator
|
||||
match me.prefix {
|
||||
|
|
@ -264,9 +264,9 @@ impl GenericPathUnsafe for Path {
|
|||
}
|
||||
match path_ {
|
||||
None => s.push_str(path),
|
||||
Some(p) => s.push_str(p.index(&FullRange)),
|
||||
Some(p) => s.push_str(&p[]),
|
||||
};
|
||||
me.update_normalized(s.index(&FullRange))
|
||||
me.update_normalized(&s[])
|
||||
}
|
||||
|
||||
if !path.is_empty() {
|
||||
|
|
@ -274,7 +274,7 @@ impl GenericPathUnsafe for Path {
|
|||
match prefix {
|
||||
Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => {
|
||||
// cwd-relative path, self is on the same volume
|
||||
append_path(self, path.index(&(prefix_len(prefix)..)));
|
||||
append_path(self, &path[prefix_len(prefix)..]);
|
||||
}
|
||||
Some(_) => {
|
||||
// absolute path, or cwd-relative and self is not same volume
|
||||
|
|
@ -320,7 +320,7 @@ impl GenericPath for Path {
|
|||
/// Always returns a `Some` value.
|
||||
#[inline]
|
||||
fn as_str<'a>(&'a self) -> Option<&'a str> {
|
||||
Some(self.repr.index(&FullRange))
|
||||
Some(&self.repr[])
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
@ -342,21 +342,21 @@ impl GenericPath for Path {
|
|||
/// Always returns a `Some` value.
|
||||
fn dirname_str<'a>(&'a self) -> Option<&'a str> {
|
||||
Some(match self.sepidx_or_prefix_len() {
|
||||
None if ".." == self.repr => self.repr.index(&FullRange),
|
||||
None if ".." == self.repr => &self.repr[],
|
||||
None => ".",
|
||||
Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
|
||||
self.repr.index(&FullRange)
|
||||
Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
|
||||
&self.repr[]
|
||||
}
|
||||
Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => {
|
||||
self.repr.index(&FullRange)
|
||||
Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => {
|
||||
&self.repr[]
|
||||
}
|
||||
Some((0,idxa,_)) => self.repr.index(&(0..idxa)),
|
||||
Some((0,idxa,_)) => &self.repr[0..idxa],
|
||||
Some((idxb,idxa,_)) => {
|
||||
match self.prefix {
|
||||
Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
|
||||
self.repr.index(&(0..idxa))
|
||||
&self.repr[0..idxa]
|
||||
}
|
||||
_ => self.repr.index(&(0..idxb))
|
||||
_ => &self.repr[0..idxb]
|
||||
}
|
||||
}
|
||||
})
|
||||
|
|
@ -370,13 +370,13 @@ impl GenericPath for Path {
|
|||
/// See `GenericPath::filename_str` for info.
|
||||
/// Always returns a `Some` value if `filename` returns a `Some` value.
|
||||
fn filename_str<'a>(&'a self) -> Option<&'a str> {
|
||||
let repr = self.repr.index(&FullRange);
|
||||
let repr = &self.repr[];
|
||||
match self.sepidx_or_prefix_len() {
|
||||
None if "." == repr || ".." == repr => None,
|
||||
None => Some(repr),
|
||||
Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None,
|
||||
Some((_,idxa,end)) if &repr[idxa..end] == ".." => None,
|
||||
Some((_,idxa,end)) if idxa == end => None,
|
||||
Some((_,idxa,end)) => Some(repr.index(&(idxa..end)))
|
||||
Some((_,idxa,end)) => Some(&repr[idxa..end])
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -408,7 +408,7 @@ impl GenericPath for Path {
|
|||
true
|
||||
}
|
||||
Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
|
||||
Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false,
|
||||
Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => false,
|
||||
Some((idxb,idxa,_)) => {
|
||||
let trunc = match self.prefix {
|
||||
Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
|
||||
|
|
@ -428,15 +428,15 @@ impl GenericPath for Path {
|
|||
if self.prefix.is_some() {
|
||||
Some(Path::new(match self.prefix {
|
||||
Some(DiskPrefix) if self.is_absolute() => {
|
||||
self.repr.index(&(0..(self.prefix_len()+1)))
|
||||
&self.repr[0..(self.prefix_len()+1)]
|
||||
}
|
||||
Some(VerbatimDiskPrefix) => {
|
||||
self.repr.index(&(0..(self.prefix_len()+1)))
|
||||
&self.repr[0..(self.prefix_len()+1)]
|
||||
}
|
||||
_ => self.repr.index(&(0..self.prefix_len()))
|
||||
_ => &self.repr[0..self.prefix_len()]
|
||||
}))
|
||||
} else if is_vol_relative(self) {
|
||||
Some(Path::new(self.repr.index(&(0..1))))
|
||||
Some(Path::new(&self.repr[0..1]))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
|
|
@ -455,7 +455,7 @@ impl GenericPath for Path {
|
|||
fn is_absolute(&self) -> bool {
|
||||
match self.prefix {
|
||||
Some(DiskPrefix) => {
|
||||
let rest = self.repr.index(&(self.prefix_len()..));
|
||||
let rest = &self.repr[self.prefix_len()..];
|
||||
rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE
|
||||
}
|
||||
Some(_) => true,
|
||||
|
|
@ -630,15 +630,15 @@ impl Path {
|
|||
/// Does not distinguish between absolute and cwd-relative paths, e.g.
|
||||
/// C:\foo and C:foo.
|
||||
pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
|
||||
let repr = self.repr.index(&FullRange);
|
||||
let repr = &self.repr[];
|
||||
let s = match self.prefix {
|
||||
Some(_) => {
|
||||
let plen = self.prefix_len();
|
||||
if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE {
|
||||
repr.index(&((plen+1)..))
|
||||
} else { repr.index(&(plen..)) }
|
||||
&repr[(plen+1)..]
|
||||
} else { &repr[plen..] }
|
||||
}
|
||||
None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)),
|
||||
None if repr.as_bytes()[0] == SEP_BYTE => &repr[1..],
|
||||
None => repr
|
||||
};
|
||||
let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr
|
||||
|
|
@ -658,8 +658,8 @@ impl Path {
|
|||
}
|
||||
|
||||
fn equiv_prefix(&self, other: &Path) -> bool {
|
||||
let s_repr = self.repr.index(&FullRange);
|
||||
let o_repr = other.repr.index(&FullRange);
|
||||
let s_repr = &self.repr[];
|
||||
let o_repr = &other.repr[];
|
||||
match (self.prefix, other.prefix) {
|
||||
(Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
|
||||
self.is_absolute() &&
|
||||
|
|
@ -676,14 +676,14 @@ impl Path {
|
|||
o_repr.as_bytes()[4].to_ascii_lowercase()
|
||||
}
|
||||
(Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
|
||||
s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len()))
|
||||
&s_repr[2..self.prefix_len()] == &o_repr[8..other.prefix_len()]
|
||||
}
|
||||
(Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
|
||||
s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len()))
|
||||
&s_repr[8..self.prefix_len()] == &o_repr[2..other.prefix_len()]
|
||||
}
|
||||
(None, None) => true,
|
||||
(a, b) if a == b => {
|
||||
s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len()))
|
||||
&s_repr[0..self.prefix_len()] == &o_repr[0..other.prefix_len()]
|
||||
}
|
||||
_ => false
|
||||
}
|
||||
|
|
@ -737,7 +737,7 @@ impl Path {
|
|||
match prefix.unwrap() {
|
||||
DiskPrefix => {
|
||||
let len = prefix_len(prefix) + is_abs as uint;
|
||||
let mut s = String::from_str(s.index(&(0..len)));
|
||||
let mut s = String::from_str(&s[0..len]);
|
||||
unsafe {
|
||||
let v = s.as_mut_vec();
|
||||
v[0] = (*v)[0].to_ascii_uppercase();
|
||||
|
|
@ -752,7 +752,7 @@ impl Path {
|
|||
}
|
||||
VerbatimDiskPrefix => {
|
||||
let len = prefix_len(prefix) + is_abs as uint;
|
||||
let mut s = String::from_str(s.index(&(0..len)));
|
||||
let mut s = String::from_str(&s[0..len]);
|
||||
unsafe {
|
||||
let v = s.as_mut_vec();
|
||||
v[4] = (*v)[4].to_ascii_uppercase();
|
||||
|
|
@ -762,14 +762,14 @@ impl Path {
|
|||
_ => {
|
||||
let plen = prefix_len(prefix);
|
||||
if s.len() > plen {
|
||||
Some(String::from_str(s.index(&(0..plen))))
|
||||
Some(String::from_str(&s[0..plen]))
|
||||
} else { None }
|
||||
}
|
||||
}
|
||||
} else if is_abs && comps.is_empty() {
|
||||
Some(repeat(SEP).take(1).collect())
|
||||
} else {
|
||||
let prefix_ = s.index(&(0..prefix_len(prefix)));
|
||||
let prefix_ = &s[0..prefix_len(prefix)];
|
||||
let n = prefix_.len() +
|
||||
if is_abs { comps.len() } else { comps.len() - 1} +
|
||||
comps.iter().map(|v| v.len()).sum();
|
||||
|
|
@ -780,15 +780,15 @@ impl Path {
|
|||
s.push(':');
|
||||
}
|
||||
Some(VerbatimDiskPrefix) => {
|
||||
s.push_str(prefix_.index(&(0..4)));
|
||||
s.push_str(&prefix_[0..4]);
|
||||
s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
|
||||
s.push_str(prefix_.index(&(5..)));
|
||||
s.push_str(&prefix_[5..]);
|
||||
}
|
||||
Some(UNCPrefix(a,b)) => {
|
||||
s.push_str("\\\\");
|
||||
s.push_str(prefix_.index(&(2..(a+2))));
|
||||
s.push_str(&prefix_[2..(a+2)]);
|
||||
s.push(SEP);
|
||||
s.push_str(prefix_.index(&((3+a)..(3+a+b))));
|
||||
s.push_str(&prefix_[(3+a)..(3+a+b)]);
|
||||
}
|
||||
Some(_) => s.push_str(prefix_),
|
||||
None => ()
|
||||
|
|
@ -813,8 +813,8 @@ impl Path {
|
|||
|
||||
fn update_sepidx(&mut self) {
|
||||
let s = if self.has_nonsemantic_trailing_slash() {
|
||||
self.repr.index(&(0..(self.repr.len()-1)))
|
||||
} else { self.repr.index(&FullRange) };
|
||||
&self.repr[0..(self.repr.len()-1)]
|
||||
} else { &self.repr[] };
|
||||
let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
|
||||
is_sep
|
||||
} else {
|
||||
|
|
@ -893,17 +893,17 @@ pub fn is_verbatim(path: &Path) -> bool {
|
|||
/// non-verbatim, the non-verbatim version is returned.
|
||||
/// Otherwise, None is returned.
|
||||
pub fn make_non_verbatim(path: &Path) -> Option<Path> {
|
||||
let repr = path.repr.index(&FullRange);
|
||||
let repr = &path.repr[];
|
||||
let new_path = match path.prefix {
|
||||
Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None,
|
||||
Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()),
|
||||
Some(VerbatimDiskPrefix) => {
|
||||
// \\?\D:\
|
||||
Path::new(repr.index(&(4..)))
|
||||
Path::new(&repr[4..])
|
||||
}
|
||||
Some(VerbatimUNCPrefix(_,_)) => {
|
||||
// \\?\UNC\server\share
|
||||
Path::new(format!(r"\{}", repr.index(&(7..))))
|
||||
Path::new(format!(r"\{}", &repr[7..]))
|
||||
}
|
||||
};
|
||||
if new_path.prefix.is_none() {
|
||||
|
|
@ -912,8 +912,7 @@ pub fn make_non_verbatim(path: &Path) -> Option<Path> {
|
|||
return None;
|
||||
}
|
||||
// now ensure normalization didn't change anything
|
||||
if repr.index(&(path.prefix_len()..)) ==
|
||||
new_path.repr.index(&(new_path.prefix_len()..)) {
|
||||
if &repr[path.prefix_len()..] == &new_path.repr[new_path.prefix_len()..] {
|
||||
Some(new_path)
|
||||
} else {
|
||||
None
|
||||
|
|
@ -978,13 +977,13 @@ pub enum PathPrefix {
|
|||
fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
|
||||
if path.starts_with("\\\\") {
|
||||
// \\
|
||||
path = path.index(&(2..));
|
||||
path = &path[2..];
|
||||
if path.starts_with("?\\") {
|
||||
// \\?\
|
||||
path = path.index(&(2..));
|
||||
path = &path[2..];
|
||||
if path.starts_with("UNC\\") {
|
||||
// \\?\UNC\server\share
|
||||
path = path.index(&(4..));
|
||||
path = &path[4..];
|
||||
let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) {
|
||||
Some(x) => x,
|
||||
None => (path.len(), 0)
|
||||
|
|
@ -1005,7 +1004,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
|
|||
}
|
||||
} else if path.starts_with(".\\") {
|
||||
// \\.\path
|
||||
path = path.index(&(2..));
|
||||
path = &path[2..];
|
||||
let idx = path.find('\\').unwrap_or(path.len());
|
||||
return Some(DeviceNSPrefix(idx));
|
||||
}
|
||||
|
|
@ -1030,7 +1029,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
|
|||
None => return None,
|
||||
Some(x) => x
|
||||
};
|
||||
path = path.index(&((idx_a+1)..));
|
||||
path = &path[(idx_a+1)..];
|
||||
let idx_b = path.find(f).unwrap_or(path.len());
|
||||
Some((idx_a, idx_b))
|
||||
}
|
||||
|
|
@ -1044,8 +1043,8 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option
|
|||
is_sep_verbatim
|
||||
};
|
||||
let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
|
||||
let s_ = s.index(&(prefix_len(prefix)..));
|
||||
let s_ = if is_abs { s_.index(&(1..)) } else { s_ };
|
||||
let s_ = &s[prefix_len(prefix)..];
|
||||
let s_ = if is_abs { &s_[1..] } else { s_ };
|
||||
|
||||
if is_abs && s_.is_empty() {
|
||||
return (is_abs, match prefix {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue