5 files changed, 24 insertions, 24 deletions

diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 54012b7b6..9f8066c70 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -61,12 +61,12 @@ pub use crate::{
 
 use crate::yellow::GreenNode;
 
-// TODO: pick a single name for everything. SourceFile maybe?
+// TODO: pick a single name for everything. SourceFileNode maybe?
 /// File represents a parse tree for a single Rust file.
-pub type File = ast::RootNode;
+pub type SourceFileNode = ast::RootNode;
 
-impl File {
-    fn new(green: GreenNode, errors: Vec<SyntaxError>) -> File {
+impl SourceFileNode {
+    fn new(green: GreenNode, errors: Vec<SyntaxError>) -> SourceFileNode {
         let root = SyntaxNode::new(green, errors);
         if cfg!(debug_assertions) {
             utils::validate_block_structure(root.borrowed());
@@ -74,24 +74,24 @@ impl File {
         assert_eq!(root.kind(), SyntaxKind::ROOT);
         ast::RootNode { syntax: root }
     }
-    pub fn parse(text: &str) -> File {
+    pub fn parse(text: &str) -> SourceFileNode {
         let tokens = tokenize(&text);
         let (green, errors) =
             parser_impl::parse_with(yellow::GreenBuilder::new(), text, &tokens, grammar::root);
-        File::new(green, errors)
+        SourceFileNode::new(green, errors)
     }
-    pub fn reparse(&self, edit: &AtomEdit) -> File {
+    pub fn reparse(&self, edit: &AtomEdit) -> SourceFileNode {
         self.incremental_reparse(edit)
             .unwrap_or_else(|| self.full_reparse(edit))
     }
-    pub fn incremental_reparse(&self, edit: &AtomEdit) -> Option<File> {
+    pub fn incremental_reparse(&self, edit: &AtomEdit) -> Option<SourceFileNode> {
         reparsing::incremental_reparse(self.syntax(), edit, self.errors())
-            .map(|(green_node, errors)| File::new(green_node, errors))
+            .map(|(green_node, errors)| SourceFileNode::new(green_node, errors))
     }
-    fn full_reparse(&self, edit: &AtomEdit) -> File {
+    fn full_reparse(&self, edit: &AtomEdit) -> SourceFileNode {
         let text =
             text_utils::replace_range(self.syntax().text().to_string(), edit.delete, &edit.insert);
-        File::parse(&text)
+        SourceFileNode::parse(&text)
     }
     /// Typed AST representation of the parse tree.
     pub fn ast(&self) -> ast::Root {
diff --git a/crates/ra_syntax/src/reparsing.rs b/crates/ra_syntax/src/reparsing.rs
index 3c4ea5c22..d48133166 100644
--- a/crates/ra_syntax/src/reparsing.rs
+++ b/crates/ra_syntax/src/reparsing.rs
@@ -180,7 +180,7 @@ fn merge_errors(
 #[cfg(test)]
 mod tests {
     use super::{
-        super::{test_utils::extract_range, text_utils::replace_range, utils::dump_tree, File},
+        super::{test_utils::extract_range, text_utils::replace_range, utils::dump_tree, SourceFileNode},
         reparse_block, reparse_leaf, AtomEdit, GreenNode, SyntaxError, SyntaxNodeRef,
 };
 
@@ -192,9 +192,9 @@ mod tests {
         let (range, before) = extract_range(before);
         let after = replace_range(before.clone(), range, replace_with);
 
-        let fully_reparsed = File::parse(&after);
+        let fully_reparsed = SourceFileNode::parse(&after);
         let incrementally_reparsed = {
-            let f = File::parse(&before);
+            let f = SourceFileNode::parse(&before);
             let edit = AtomEdit {
                 delete: range,
                 insert: replace_with.to_string(),
@@ -203,7 +203,7 @@ mod tests {
                 reparser(f.syntax(), &edit).expect("cannot incrementally reparse");
             let green_root = node.replace_with(green);
             let errors = super::merge_errors(f.errors(), new_errors, node, &edit);
-            File::new(green_root, errors)
+            SourceFileNode::new(green_root, errors)
         };
 
         assert_eq_text!(
diff --git a/crates/ra_syntax/src/utils.rs b/crates/ra_syntax/src/utils.rs
index cad9544be..5bbdf80bb 100644
--- a/crates/ra_syntax/src/utils.rs
+++ b/crates/ra_syntax/src/utils.rs
@@ -1,4 +1,4 @@
-use crate::{File, SyntaxKind, SyntaxNodeRef, WalkEvent};
+use crate::{SourceFileNode, SyntaxKind, SyntaxNodeRef, WalkEvent};
 use std::fmt::Write;
 use std::str;
 
@@ -45,7 +45,7 @@ pub fn dump_tree(syntax: SyntaxNodeRef) -> String {
 }
 
 pub fn check_fuzz_invariants(text: &str) {
-    let file = File::parse(text);
+    let file = SourceFileNode::parse(text);
     let root = file.syntax();
     validate_block_structure(root);
     let _ = file.ast();
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index f345dbd6e..a10b297c0 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -5,7 +5,7 @@ use arrayvec::ArrayString;
 use crate::{
     algo::visit::{visitor_ctx, VisitorCtx},
     ast::{self, AstNode},
-    File,
+    SourceFileNode,
     string_lexing::{self, CharComponentKind},
     yellow::{
         SyntaxError,
@@ -13,7 +13,7 @@ use crate::{
     },
 };
 
-pub(crate) fn validate(file: &File) -> Vec<SyntaxError> {
+pub(crate) fn validate(file: &SourceFileNode) -> Vec<SyntaxError> {
     let mut errors = Vec::new();
     for node in file.syntax().descendants() {
         let _ = visitor_ctx(&mut errors)
@@ -155,11 +155,11 @@ fn is_ascii_escape(code: char) -> bool {
 
 #[cfg(test)]
 mod test {
-    use crate::File;
+    use crate::SourceFileNode;
 
-    fn build_file(literal: &str) -> File {
+    fn build_file(literal: &str) -> SourceFileNode {
         let src = format!("const C: char = '{}';", literal);
-        File::parse(&src)
+        SourceFileNode::parse(&src)
     }
 
     fn assert_valid_char(literal: &str) {
diff --git a/crates/ra_syntax/tests/test.rs b/crates/ra_syntax/tests/test.rs
index 9d1ded093..67acc9020 100644
--- a/crates/ra_syntax/tests/test.rs
+++ b/crates/ra_syntax/tests/test.rs
@@ -11,7 +11,7 @@ use std::{
 
 use ra_syntax::{
     utils::{check_fuzz_invariants, dump_tree},
-    File,
+    SourceFileNode,
 };
 
 #[test]
@@ -25,7 +25,7 @@ fn lexer_tests() {
 #[test]
 fn parser_tests() {
     dir_tests(&["parser/inline", "parser/ok", "parser/err"], |text| {
-        let file = File::parse(text);
+        let file = SourceFileNode::parse(text);
         dump_tree(file.syntax())
     })
 }