Merge pull request #54 from ebfe/fix-build-master

phildawes · phildawes · commit ecde20615376 · 2014-09-21T20:55:38.000+01:00
Fix enum variant/type name clashes
diff --git a/src/racer/codecleaner.rs b/src/racer/codecleaner.rs
@@ -20,11 +20,11 @@ pub fn slice<'a>(src: &'a str, (begin, end): (uint, uint)) -> &'a str{
 }
 
 enum State {
-    Code,
-    Comment,
-    CommentBlock,
-    String,
-    Finished
+    StateCode,
+    StateComment,
+    StateCommentBlock,
+    StateString,
+    StateFinished
 }
 
 pub struct CodeIndicesIter<'a> {
@@ -39,11 +39,11 @@ impl<'a> Iterator<(uint, uint)> for CodeIndicesIter<'a> {
     #[inline]
     fn next(&mut self) -> Option<(uint, uint)> {
         return match self.state {
-            Code => code(self),
-            Comment => comment(self),
-            CommentBlock  => comment_block(self),
-            String => string(self),
-            Finished => None
+            StateCode => code(self),
+            StateComment => comment(self),
+            StateCommentBlock  => comment_block(self),
+            StateString => string(self),
+            StateFinished => None
         }
     }
 }
@@ -60,28 +60,28 @@ fn code(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {
         if pos > 0 && src_bytes[pos] == slash && src_bytes[pos-1] == slash {
             self_.start = pos+1;
             self_.pos = pos+1;
-            self_.state = Comment;
+            self_.state = StateComment;
             return Some((start, pos-1));
         }
 
         if pos > 0 && src_bytes[pos] == star && src_bytes[pos-1] == slash {
             self_.start = pos+1;
             self_.pos = pos+1;
-            self_.state = CommentBlock;
+            self_.state = StateCommentBlock;
             self_.nesting_level = 0;
             return Some((start, pos-1));
         }
 
         if src_bytes[pos] == dblquote {
             self_.start = pos+1;
             self_.pos = pos+1;
-            self_.state = String;
+            self_.state = StateString;
             return Some((start, pos+1)); // include the dblquote in the code
         }
 
         pos += 1;
     }
-    self_.state = Finished;
+    self_.state = StateFinished;
     return Some((start, end));
 }
 
@@ -94,12 +94,12 @@ fn comment(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {
         if src_bytes[pos] == newline {
             self_.start = pos+1;
             self_.pos = pos+1;
-            self_.state = Code;
+            self_.state = StateCode;
             return code(self_);
         }
         pos += 1;
     }
-    self_.state = Finished;
+    self_.state = StateFinished;
     return Some((start, end));
 }
 
@@ -118,15 +118,15 @@ fn comment_block(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {
             if self_.nesting_level == 0 {
                 self_.start = pos+1;
                 self_.pos = pos+1;
-                self_.state = Code;
+                self_.state = StateCode;
                 return code(self_);
             } else {
                 self_.nesting_level -= 1;
             }
         }
         pos += 1;
     }
-    self_.state = Finished;
+    self_.state = StateFinished;
     return Some((start, end));
 }
 
@@ -152,18 +152,18 @@ fn string(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {
         if src_bytes[pos] == dblquote && !escaped(src_bytes, pos) {
             self_.start = pos;   // include the dblquote as code
             self_.pos = pos+1;
-            self_.state = Code;
+            self_.state = StateCode;
             return code(self_);
         }
         pos += 1;
     }
-    self_.state = Finished;
+    self_.state = StateFinished;
     return Some((start, end));
 }
 
 /// Returns indices of chunks of code (minus comments and string contents)
 pub fn code_chunks<'a>(src: &'a str) -> CodeIndicesIter<'a> {
-    CodeIndicesIter { src: src, start: 0, pos: 0, state: Code, nesting_level: 0 }
+    CodeIndicesIter { src: src, start: 0, pos: 0, state: StateCode, nesting_level: 0 }
 }
 
 #[test]
diff --git a/src/racer/mod.rs b/src/racer/mod.rs
@@ -45,8 +45,8 @@ pub enum Namespace {
 
 #[deriving(Show)]
 pub enum CompletionType {
-    Field,
-    Path
+    CompleteField,
+    CompletePath
 }
 
 #[deriving(Clone)]
@@ -145,7 +145,7 @@ pub fn complete_from_file(src: &str, filepath: &path::Path, pos: uint) -> vec::M
     let mut out = Vec::new();
 
     match completetype {
-        Path => {
+        CompletePath => {
             let mut v : Vec<&str> = expr.split_str("::").collect();
             let mut global = false;
             if v[0] == "" {      // i.e. starts with '::' e.g. ::std::io::blah
@@ -162,7 +162,7 @@ pub fn complete_from_file(src: &str, filepath: &path::Path, pos: uint) -> vec::M
                 out.push(m);
             }
         },
-        Field => {
+        CompleteField => {
             let context = ast::get_type_of(contextstr.to_string(), filepath, pos);
             debug!("PHIL complete_from_file context is {}", context);
             context.map(|m| {
@@ -190,7 +190,7 @@ pub fn find_definition_(src: &str, filepath: &path::Path, pos: uint) -> Option<M
     debug!("PHIL searching for |{}| |{}| {:?}",contextstr, searchstr, completetype);
 
     return match completetype {
-        Path => {
+        CompletePath => {
             let mut v : Vec<&str> = expr.split_str("::").collect();
             let mut global = false;
             if v[0] == "" {      // i.e. starts with '::' e.g. ::std::io::blah
@@ -206,7 +206,7 @@ pub fn find_definition_(src: &str, filepath: &path::Path, pos: uint) -> Option<M
             return nameres::resolve_path(&path, filepath, pos, 
                                          ExactMatch, BothNamespaces).nth(0);
         },
-        Field => {
+        CompleteField => {
             let context = ast::get_type_of(contextstr.to_string(), filepath, pos);
             debug!("PHIL context is {}",context);
 
diff --git a/src/racer/scopes.rs b/src/racer/scopes.rs
@@ -140,14 +140,14 @@ pub fn split_into_context_and_completion<'a>(s: &'a str) -> (&'a str, &'a str, r
     }
 
     if start != 0 && s_bytes[start-1] == dot {    // field completion
-        return (s.slice_to(start-1), s.slice_from(start), racer::Field);
+        return (s.slice_to(start-1), s.slice_from(start), racer::CompleteField);
     }
 
     if start > 0 && s_bytes[start-1] == colon {  // path completion
-        return (s.slice_to(start-2), s.slice_from(start), racer::Path);
+        return (s.slice_to(start-2), s.slice_from(start), racer::CompletePath);
     }
 
-    return (s.slice_to(start), s.slice_from(start), racer::Path);
+    return (s.slice_to(start), s.slice_from(start), racer::CompletePath);
 }
 
 pub fn get_start_of_search_expr(msrc: &str, point: uint) -> uint {

Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@ pub fn slice<'a>(src: &'a str, (begin, end): (uint, uint)) -> &'a str{`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`enum State {`
`23`		`- Code,`
`24`		`- Comment,`
`25`		`- CommentBlock,`
`26`		`- String,`
`27`		`- Finished`
	`23`	`+ StateCode,`
	`24`	`+ StateComment,`
	`25`	`+ StateCommentBlock,`
	`26`	`+ StateString,`
	`27`	`+ StateFinished`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`pub struct CodeIndicesIter<'a> {`
`@@ -39,11 +39,11 @@ impl<'a> Iterator<(uint, uint)> for CodeIndicesIter<'a> {`
`39`	`39`	`#[inline]`
`40`	`40`	`fn next(&mut self) -> Option<(uint, uint)> {`
`41`	`41`	`return match self.state {`
`42`		`- Code => code(self),`
`43`		`- Comment => comment(self),`
`44`		`- CommentBlock => comment_block(self),`
`45`		`- String => string(self),`
`46`		`- Finished => None`
	`42`	`+ StateCode => code(self),`
	`43`	`+ StateComment => comment(self),`
	`44`	`+ StateCommentBlock => comment_block(self),`
	`45`	`+ StateString => string(self),`
	`46`	`+ StateFinished => None`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`
`@@ -60,28 +60,28 @@ fn code(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {`
`60`	`60`	`if pos > 0 && src_bytes[pos] == slash && src_bytes[pos-1] == slash {`
`61`	`61`	`self_.start = pos+1;`
`62`	`62`	`self_.pos = pos+1;`
`63`		`- self_.state = Comment;`
	`63`	`+ self_.state = StateComment;`
`64`	`64`	`return Some((start, pos-1));`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`if pos > 0 && src_bytes[pos] == star && src_bytes[pos-1] == slash {`
`68`	`68`	`self_.start = pos+1;`
`69`	`69`	`self_.pos = pos+1;`
`70`		`- self_.state = CommentBlock;`
	`70`	`+ self_.state = StateCommentBlock;`
`71`	`71`	`self_.nesting_level = 0;`
`72`	`72`	`return Some((start, pos-1));`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`if src_bytes[pos] == dblquote {`
`76`	`76`	`self_.start = pos+1;`
`77`	`77`	`self_.pos = pos+1;`
`78`		`- self_.state = String;`
	`78`	`+ self_.state = StateString;`
`79`	`79`	`return Some((start, pos+1)); // include the dblquote in the code`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`pos += 1;`
`83`	`83`	`}`
`84`		`- self_.state = Finished;`
	`84`	`+ self_.state = StateFinished;`
`85`	`85`	`return Some((start, end));`
`86`	`86`	`}`
`87`	`87`
`@@ -94,12 +94,12 @@ fn comment(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {`
`94`	`94`	`if src_bytes[pos] == newline {`
`95`	`95`	`self_.start = pos+1;`
`96`	`96`	`self_.pos = pos+1;`
`97`		`- self_.state = Code;`
	`97`	`+ self_.state = StateCode;`
`98`	`98`	`return code(self_);`
`99`	`99`	`}`
`100`	`100`	`pos += 1;`
`101`	`101`	`}`
`102`		`- self_.state = Finished;`
	`102`	`+ self_.state = StateFinished;`
`103`	`103`	`return Some((start, end));`
`104`	`104`	`}`
`105`	`105`
`@@ -118,15 +118,15 @@ fn comment_block(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {`
`118`	`118`	`if self_.nesting_level == 0 {`
`119`	`119`	`self_.start = pos+1;`
`120`	`120`	`self_.pos = pos+1;`
`121`		`- self_.state = Code;`
	`121`	`+ self_.state = StateCode;`
`122`	`122`	`return code(self_);`
`123`	`123`	`} else {`
`124`	`124`	`self_.nesting_level -= 1;`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`	`pos += 1;`
`128`	`128`	`}`
`129`		`- self_.state = Finished;`
	`129`	`+ self_.state = StateFinished;`
`130`	`130`	`return Some((start, end));`
`131`	`131`	`}`
`132`	`132`
`@@ -152,18 +152,18 @@ fn string(self_: &mut CodeIndicesIter) -> Option<(uint,uint)> {`
`152`	`152`	`if src_bytes[pos] == dblquote && !escaped(src_bytes, pos) {`
`153`	`153`	`self_.start = pos; // include the dblquote as code`
`154`	`154`	`self_.pos = pos+1;`
`155`		`- self_.state = Code;`
	`155`	`+ self_.state = StateCode;`
`156`	`156`	`return code(self_);`
`157`	`157`	`}`
`158`	`158`	`pos += 1;`
`159`	`159`	`}`
`160`		`- self_.state = Finished;`
	`160`	`+ self_.state = StateFinished;`
`161`	`161`	`return Some((start, end));`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`/// Returns indices of chunks of code (minus comments and string contents)`
`165`	`165`	`pub fn code_chunks<'a>(src: &'a str) -> CodeIndicesIter<'a> {`
`166`		`- CodeIndicesIter { src: src, start: 0, pos: 0, state: Code, nesting_level: 0 }`
	`166`	`+ CodeIndicesIter { src: src, start: 0, pos: 0, state: StateCode, nesting_level: 0 }`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -140,14 +140,14 @@ pub fn split_into_context_and_completion<'a>(s: &'a str) -> (&'a str, &'a str, r`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`if start != 0 && s_bytes[start-1] == dot { // field completion`
`143`		`- return (s.slice_to(start-1), s.slice_from(start), racer::Field);`
	`143`	`+ return (s.slice_to(start-1), s.slice_from(start), racer::CompleteField);`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`if start > 0 && s_bytes[start-1] == colon { // path completion`
`147`		`- return (s.slice_to(start-2), s.slice_from(start), racer::Path);`
	`147`	`+ return (s.slice_to(start-2), s.slice_from(start), racer::CompletePath);`
`148`	`148`	`}`
`149`	`149`
`150`		`- return (s.slice_to(start), s.slice_from(start), racer::Path);`
	`150`	`+ return (s.slice_to(start), s.slice_from(start), racer::CompletePath);`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`pub fn get_start_of_search_expr(msrc: &str, point: uint) -> uint {`