7 files changed, 113 insertions, 10 deletions

diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 8fb6b6408..e968c9728 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -30,6 +30,12 @@ pub trait NameOwner<'a>: AstNode<'a> {
     }
 }
 
+pub trait VisibilityOwner<'a>: AstNode<'a> {
+    fn visibility(self) -> Option<Visibility<'a>> {
+        child_opt(self)
+    }
+}
+
 pub trait LoopBodyOwner<'a>: AstNode<'a> {
     fn loop_body(self) -> Option<Block<'a>> {
         child_opt(self)
@@ -48,10 +54,40 @@ pub trait FnDefOwner<'a>: AstNode<'a> {
     }
 }
 
+// ModuleItem
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ItemOrMacro<'a> {
+    Item(ModuleItem<'a>),
+    Macro(MacroCall<'a>),
+}
+
+impl<'a> AstNode<'a> for ItemOrMacro<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        let res = if let Some(item) = ModuleItem::cast(syntax) {
+            ItemOrMacro::Item(item)
+        } else if let Some(macro_call) = MacroCall::cast(syntax) {
+            ItemOrMacro::Macro(macro_call)
+        } else {
+            return None;
+        };
+        Some(res)
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> {
+        match self {
+            ItemOrMacro::Item(it) => it.syntax(),
+            ItemOrMacro::Macro(it) => it.syntax(),
+        }
+    }
+}
+
 pub trait ModuleItemOwner<'a>: AstNode<'a> {
     fn items(self) -> AstChildren<'a, ModuleItem<'a>> {
         children(self)
     }
+
+    fn items_with_macros(self) -> AstChildren<'a, ItemOrMacro<'a>> {
+        children(self)
+    }
 }
 
 pub trait TypeParamsOwner<'a>: AstNode<'a> {
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index c5ac90a62..c619fc130 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -695,6 +695,7 @@ impl<R: TreeRoot<RaTypes>> ConstDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::NameOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for ConstDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for ConstDef<'a> {}
@@ -810,6 +811,7 @@ impl<R: TreeRoot<RaTypes>> EnumDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::NameOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for EnumDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for EnumDef<'a> {}
@@ -1213,6 +1215,7 @@ impl<R: TreeRoot<RaTypes>> FnDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for FnDef<'a> {}
 impl<'a> ast::NameOwner<'a> for FnDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for FnDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for FnDef<'a> {}
@@ -2136,6 +2139,7 @@ impl<R: TreeRoot<RaTypes>> ModuleNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for Module<'a> {}
 impl<'a> ast::NameOwner<'a> for Module<'a> {}
 impl<'a> ast::AttrsOwner<'a> for Module<'a> {}
 impl<'a> ast::DocCommentsOwner<'a> for Module<'a> {}
@@ -2351,6 +2355,7 @@ impl<R: TreeRoot<RaTypes>> NamedFieldDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> ast::NameOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for NamedFieldDef<'a> {}
 impl<'a> NamedFieldDef<'a> {
@@ -3082,6 +3087,7 @@ impl<R: TreeRoot<RaTypes>> PosFieldNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for PosField<'a> {}
 impl<'a> ast::AttrsOwner<'a> for PosField<'a> {}
 impl<'a> PosField<'a> {
     pub fn type_ref(self) -> Option<TypeRef<'a>> {
@@ -3639,6 +3645,7 @@ impl<R: TreeRoot<RaTypes>> StaticDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for StaticDef<'a> {}
 impl<'a> ast::NameOwner<'a> for StaticDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for StaticDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for StaticDef<'a> {}
@@ -3742,6 +3749,7 @@ impl<R: TreeRoot<RaTypes>> StructDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for StructDef<'a> {}
 impl<'a> ast::NameOwner<'a> for StructDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for StructDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for StructDef<'a> {}
@@ -3902,6 +3910,7 @@ impl<R: TreeRoot<RaTypes>> TraitDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for TraitDef<'a> {}
 impl<'a> ast::NameOwner<'a> for TraitDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for TraitDef<'a> {}
 impl<'a> ast::DocCommentsOwner<'a> for TraitDef<'a> {}
@@ -4135,6 +4144,7 @@ impl<R: TreeRoot<RaTypes>> TypeDefNode<R> {
 }
 
 
+impl<'a> ast::VisibilityOwner<'a> for TypeDef<'a> {}
 impl<'a> ast::NameOwner<'a> for TypeDef<'a> {}
 impl<'a> ast::TypeParamsOwner<'a> for TypeDef<'a> {}
 impl<'a> ast::AttrsOwner<'a> for TypeDef<'a> {}
@@ -4409,6 +4419,43 @@ impl<'a> UseTreeList<'a> {
     }
 }
 
+// Visibility
+#[derive(Debug, Clone, Copy,)]
+pub struct VisibilityNode<R: TreeRoot<RaTypes> = OwnedRoot> {
+    pub(crate) syntax: SyntaxNode<R>,
+}
+pub type Visibility<'a> = VisibilityNode<RefRoot<'a>>;
+
+impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<VisibilityNode<R1>> for VisibilityNode<R2> {
+    fn eq(&self, other: &VisibilityNode<R1>) -> bool { self.syntax == other.syntax }
+}
+impl<R: TreeRoot<RaTypes>> Eq for VisibilityNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for VisibilityNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+}
+
+impl<'a> AstNode<'a> for Visibility<'a> {
+    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+        match syntax.kind() {
+            VISIBILITY => Some(Visibility { syntax }),
+            _ => None,
+        }
+    }
+    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+}
+
+impl<R: TreeRoot<RaTypes>> VisibilityNode<R> {
+    pub fn borrowed(&self) -> Visibility {
+        VisibilityNode { syntax: self.syntax.borrowed() }
+    }
+    pub fn owned(&self) -> VisibilityNode {
+        VisibilityNode { syntax: self.syntax.owned() }
+    }
+}
+
+
+impl<'a> Visibility<'a> {}
+
 // WhereClause
 #[derive(Debug, Clone, Copy,)]
 pub struct WhereClauseNode<R: TreeRoot<RaTypes> = OwnedRoot> {
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index aab4839a9..2abb9da61 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -247,6 +247,7 @@ Grammar(
         ),
         "FnDef": (
             traits: [
+                "VisibilityOwner",
                 "NameOwner",
                 "TypeParamsOwner",
                 "AttrsOwner",
@@ -257,6 +258,7 @@ Grammar(
         "RetType": (options: ["TypeRef"]),
         "StructDef": (
             traits: [
+                "VisibilityOwner",
                 "NameOwner",
                 "TypeParamsOwner",
                 "AttrsOwner",
@@ -264,10 +266,11 @@ Grammar(
             ]
         ),
         "NamedFieldDefList": (collections: [["fields", "NamedFieldDef"]]),
-        "NamedFieldDef": ( traits: ["NameOwner", "AttrsOwner"], options: ["TypeRef"] ),
+        "NamedFieldDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner"], options: ["TypeRef"] ),
         "PosFieldList": (collections: [["fields", "PosField"]]),
-        "PosField": ( traits: ["AttrsOwner"], options: ["TypeRef"]),
+        "PosField": ( traits: ["VisibilityOwner", "AttrsOwner"], options: ["TypeRef"]),
         "EnumDef": ( traits: [
+            "VisibilityOwner",
             "NameOwner",
             "TypeParamsOwner",
             "AttrsOwner",
@@ -275,27 +278,30 @@ Grammar(
         ], options: [["variant_list", "EnumVariantList"]] ),
         "EnumVariantList": ( collections: [["variants", "EnumVariant"]] ),
         "EnumVariant": ( traits: ["NameOwner"], options: ["Expr"] ),
-        "TraitDef": ( traits: ["NameOwner", "AttrsOwner", "DocCommentsOwner"] ),
+        "TraitDef": ( traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner"] ),
         "Module": (
-            traits: ["NameOwner", "AttrsOwner", "DocCommentsOwner" ],
+            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner" ],
             options: [ "ItemList" ]
         ),
         "ItemList": (
             traits: [ "FnDefOwner", "ModuleItemOwner" ],
         ),
         "ConstDef": ( traits: [
+            "VisibilityOwner",
             "NameOwner",
             "TypeParamsOwner",
             "AttrsOwner",
             "DocCommentsOwner"
         ] ),
         "StaticDef": ( traits: [
+            "VisibilityOwner",
             "NameOwner",
             "TypeParamsOwner",
             "AttrsOwner",
             "DocCommentsOwner"
         ] ),
         "TypeDef": ( traits: [
+            "VisibilityOwner",
             "NameOwner",
             "TypeParamsOwner",
             "AttrsOwner",
@@ -482,6 +488,7 @@ Grammar(
             ],
         ),
 
+        "Visibility": (),
         "Name": (),
         "NameRef": (),
         "MacroCall": ( options: [ "TokenTree", "Path" ] ),
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 34a3aabef..6753c513f 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -51,7 +51,7 @@ use ra_text_edit::AtomTextEdit;
 use crate::yellow::GreenNode;
 
 /// `SourceFileNode` represents a parse tree for a single Rust file.
-pub use crate::ast::SourceFileNode;
+pub use crate::ast::{SourceFile, SourceFileNode};
 
 impl SourceFileNode {
     fn new(green: GreenNode, errors: Vec<SyntaxError>) -> SourceFileNode {
diff --git a/crates/ra_syntax/src/validation/byte.rs b/crates/ra_syntax/src/validation/byte.rs
index d0897eeed..714224b09 100644
--- a/crates/ra_syntax/src/validation/byte.rs
+++ b/crates/ra_syntax/src/validation/byte.rs
@@ -88,7 +88,9 @@ fn validate_byte_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxErr
 
 fn validate_byte_code_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
     // A ByteCodeEscape has 4 chars, example: `\xDD`
-    if text.len() < 4 {
+    if !text.is_ascii() {
+        errors.push(SyntaxError::new(MalformedByteCodeEscape, range));
+    } else if text.chars().count() < 4 {
         errors.push(SyntaxError::new(TooShortByteCodeEscape, range));
     } else {
         assert!(
diff --git a/crates/ra_syntax/src/validation/char.rs b/crates/ra_syntax/src/validation/char.rs
index 10d3d1dec..1d6fe8837 100644
--- a/crates/ra_syntax/src/validation/char.rs
+++ b/crates/ra_syntax/src/validation/char.rs
@@ -89,12 +89,17 @@ pub(super) fn is_ascii_escape(code: char) -> bool {
 
 fn validate_ascii_code_escape(text: &str, range: TextRange, errors: &mut Vec<SyntaxError>) {
     // An AsciiCodeEscape has 4 chars, example: `\xDD`
-    if text.len() < 4 {
+    if !text.is_ascii() {
+        // TODO: Give a more precise error message (say what the invalid character was)
+        errors.push(SyntaxError::new(AsciiCodeEscapeOutOfRange, range));
+    } else if text.chars().count() < 4 {
         errors.push(SyntaxError::new(TooShortAsciiCodeEscape, range));
     } else {
-        assert!(
-            text.chars().count() == 4,
-            "AsciiCodeEscape cannot be longer than 4 chars"
+        assert_eq!(
+            text.chars().count(),
+            4,
+            "AsciiCodeEscape cannot be longer than 4 chars, but text '{}' is",
+            text,
         );
 
         match u8::from_str_radix(&text[2..], 16) {
diff --git a/crates/ra_syntax/src/yellow/syntax_text.rs b/crates/ra_syntax/src/yellow/syntax_text.rs
index 46bde9a08..783dca214 100644
--- a/crates/ra_syntax/src/yellow/syntax_text.rs
+++ b/crates/ra_syntax/src/yellow/syntax_text.rs
@@ -119,3 +119,9 @@ impl SyntaxTextSlice for ops::Range<TextUnit> {
         TextRange::from_to(self.start, self.end).restrict(range)
     }
 }
+
+impl From<SyntaxText<'_>> for String {
+    fn from(text: SyntaxText) -> String {
+        text.to_string()
+    }
+}