Merge #1524

bors[bot] · matklad · bors[bot] · commit 8bb81d7418db · 2019-07-12T16:42:06.000Z
1524: make Parse fields private r=matklad a=matklad



Co-authored-by: Aleksey Kladov &lt;aleksey.kladov@gmail.com&gt;
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
@@ -71,11 +71,11 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
     where
         F: FnOnce(AssistCtx<DB>) -> T,
     {
-        let source_file = &db.parse(frange.file_id).tree;
+        let parse = db.parse(frange.file_id);
         let assist =
             if should_compute_edit { Assist::Resolved(vec![]) } else { Assist::Unresolved(vec![]) };
 
-        let ctx = AssistCtx { db, frange, source_file, should_compute_edit, assist };
+        let ctx = AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit, assist };
         f(ctx)
     }
 
diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
@@ -278,16 +278,17 @@ impl AstBuilder<ast::NameRef> {
 }
 
 fn ast_node_from_file_text<N: AstNode>(text: &str) -> TreeArc<N> {
-    let file = SourceFile::parse(text).tree;
-    let res = file.syntax().descendants().find_map(N::cast).unwrap().to_owned();
+    let parse = SourceFile::parse(text);
+    let res = parse.tree().syntax().descendants().find_map(N::cast).unwrap().to_owned();
     res
 }
 
 mod tokens {
     use once_cell::sync::Lazy;
     use ra_syntax::{AstNode, SourceFile, SyntaxKind::*, SyntaxToken, TreeArc, T};
 
-    static SOURCE_FILE: Lazy<TreeArc<SourceFile>> = Lazy::new(|| SourceFile::parse(",\n; ;").tree);
+    static SOURCE_FILE: Lazy<TreeArc<SourceFile>> =
+        Lazy::new(|| SourceFile::parse(",\n; ;").tree().to_owned());
 
     pub(crate) fn comma() -> SyntaxToken<'static> {
         SOURCE_FILE
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
@@ -102,7 +102,7 @@ fn main() -> Result<()> {
 
 fn file() -> Result<TreeArc<SourceFile>> {
     let text = read_stdin()?;
-    Ok(SourceFile::parse(&text).tree)
+    Ok(SourceFile::parse(&text).tree().to_owned())
 }
 
 fn read_stdin() -> Result<String> {
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
@@ -167,7 +167,7 @@ impl ModuleSource {
     ) -> ModuleSource {
         match (file_id, decl_id) {
             (Some(file_id), _) => {
-                let source_file = db.parse(file_id).tree;
+                let source_file = db.parse(file_id).tree().to_owned();
                 ModuleSource::SourceFile(source_file)
             }
             (None, Some(item_id)) => {
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
@@ -71,7 +71,8 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
         }
         let source_map = self.func.body_source_map(db);
         let file_id = self.func.source(db).file_id;
-        let source_file = db.parse(file_id.original_file(db)).tree;
+        let parse = db.parse(file_id.original_file(db));
+        let source_file = parse.tree();
         if let Some(field_list_node) = source_map
             .expr_syntax(id)
             .map(|ptr| ptr.to_node(source_file.syntax()))
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
@@ -60,7 +60,7 @@ impl HirFileId {
         file_id: HirFileId,
     ) -> Option<TreeArc<SyntaxNode>> {
         match file_id.0 {
-            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree.syntax().to_owned()),
+            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().to_owned()),
             HirFileIdRepr::Macro(macro_file) => db.parse_macro(macro_file),
         }
     }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
@@ -49,8 +49,8 @@ pub fn module_from_declaration(
 
 /// Locates the module by position in the source code.
 pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
-    let file = db.parse(position.file_id).tree;
-    match find_node_at_offset::<ast::Module>(file.syntax(), position.offset) {
+    let parse = db.parse(position.file_id);
+    match find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
         Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m),
         _ => module_from_file_id(db, position.file_id),
     }
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
@@ -10,8 +10,8 @@ use crate::{db::RootDatabase, CallInfo, FilePosition, FunctionSignature};
 
 /// Computes parameter information for the given call expression.
 pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
-    let file = db.parse(position.file_id).tree;
-    let syntax = file.syntax();
+    let parse = db.parse(position.file_id);
+    let syntax = parse.tree().syntax();
 
     // Find the calling expression and it's NameRef
     let calling_node = FnCallNode::with_node(syntax, position.offset)?;
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
@@ -135,8 +135,8 @@ impl LibraryData {
         files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
     ) -> LibraryData {
         let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, _, text)| {
-            let file = SourceFile::parse(text).tree;
-            (*file_id, file)
+            let parse = SourceFile::parse(text);
+            (*file_id, parse)
         }));
         let mut root_change = RootChange::default();
         root_change.added = files
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -48,7 +48,7 @@ impl<'a> CompletionContext<'a> {
     ) -> Option<CompletionContext<'a>> {
         let module = source_binder::module_from_position(db, position);
         let token =
-            find_token_at_offset(original_parse.tree.syntax(), position.offset).left_biased()?;
+            find_token_at_offset(original_parse.tree().syntax(), position.offset).left_biased()?;
         let analyzer =
             hir::SourceAnalyzer::new(db, position.file_id, token.parent(), Some(position.offset));
         let mut ctx = CompletionContext {
@@ -89,7 +89,7 @@ impl<'a> CompletionContext<'a> {
         // actual completion.
         let file = {
             let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string());
-            original_parse.reparse(&edit).tree
+            original_parse.reparse(&edit).tree().to_owned()
         };
 
         // First, let's try to complete a reference to some declaration.
@@ -100,7 +100,7 @@ impl<'a> CompletionContext<'a> {
                 self.is_param = true;
                 return;
             }
-            self.classify_name_ref(&original_parse.tree, name_ref);
+            self.classify_name_ref(original_parse.tree(), name_ref);
         }
 
         // Otherwise, see if this is a declaration. We can use heuristics to
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
@@ -27,14 +27,14 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
     let parse = db.parse(file_id);
     let mut res = Vec::new();
 
-    res.extend(parse.errors.iter().map(|err| Diagnostic {
+    res.extend(parse.errors().iter().map(|err| Diagnostic {
         range: location_to_range(err.location()),
         message: format!("Syntax Error: {}", err),
         severity: Severity::Error,
         fix: None,
     }));
 
-    for node in parse.tree.syntax().descendants() {
+    for node in parse.tree().syntax().descendants() {
         check_unnecessary_braces_in_use_statement(&mut res, file_id, node);
         check_struct_shorthand_initialization(&mut res, file_id, node);
     }
@@ -181,18 +181,18 @@ mod tests {
     type DiagnosticChecker = fn(&mut Vec<Diagnostic>, FileId, &SyntaxNode) -> Option<()>;
 
     fn check_not_applicable(code: &str, func: DiagnosticChecker) {
-        let file = SourceFile::parse(code).tree;
+        let parse = SourceFile::parse(code);
         let mut diagnostics = Vec::new();
-        for node in file.syntax().descendants() {
+        for node in parse.tree().syntax().descendants() {
             func(&mut diagnostics, FileId(0), node);
         }
         assert!(diagnostics.is_empty());
     }
 
     fn check_apply(before: &str, after: &str, func: DiagnosticChecker) {
-        let file = SourceFile::parse(before).tree;
+        let parse = SourceFile::parse(before);
         let mut diagnostics = Vec::new();
-        for node in file.syntax().descendants() {
+        for node in parse.tree().syntax().descendants() {
             func(&mut diagnostics, FileId(0), node);
         }
         let diagnostic =
diff --git a/crates/ra_ide_api/src/display/navigation_target.rs b/crates/ra_ide_api/src/display/navigation_target.rs
@@ -93,8 +93,8 @@ impl NavigationTarget {
         file_id: FileId,
         pat: AstPtr<ast::Pat>,
     ) -> NavigationTarget {
-        let file = db.parse(file_id).tree;
-        let (name, full_range) = match pat.to_node(file.syntax()).kind() {
+        let parse = db.parse(file_id);
+        let (name, full_range) = match pat.to_node(parse.tree().syntax()).kind() {
             ast::PatKind::BindPat(pat) => return NavigationTarget::from_bind_pat(file_id, &pat),
             _ => ("_".into(), pat.syntax_node_ptr().range()),
         };
@@ -315,8 +315,8 @@ impl NavigationTarget {
 }
 
 pub(crate) fn docs_from_symbol(db: &RootDatabase, symbol: &FileSymbol) -> Option<String> {
-    let file = db.parse(symbol.file_id).tree;
-    let node = symbol.ptr.to_node(file.syntax()).to_owned();
+    let parse = db.parse(symbol.file_id);
+    let node = symbol.ptr.to_node(parse.tree().syntax()).to_owned();
 
     fn doc_comments<N: ast::DocCommentsOwner>(node: &N) -> Option<String> {
         node.doc_comment_text()
@@ -341,8 +341,8 @@ pub(crate) fn docs_from_symbol(db: &RootDatabase, symbol: &FileSymbol) -> Option
 ///
 /// e.g. `struct Name`, `enum Name`, `fn Name`
 pub(crate) fn description_from_symbol(db: &RootDatabase, symbol: &FileSymbol) -> Option<String> {
-    let file = db.parse(symbol.file_id).tree;
-    let node = symbol.ptr.to_node(file.syntax()).to_owned();
+    let parse = db.parse(symbol.file_id);
+    let node = symbol.ptr.to_node(parse.tree().syntax()).to_owned();
 
     visitor()
         .visit(|node: &ast::FnDef| node.short_label())
diff --git a/crates/ra_ide_api/src/extend_selection.rs b/crates/ra_ide_api/src/extend_selection.rs
@@ -11,8 +11,8 @@ use crate::{db::RootDatabase, FileRange};
 
 // FIXME: restore macro support
 pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRange {
-    let source_file = db.parse(frange.file_id).tree;
-    try_extend_selection(source_file.syntax(), frange.range).unwrap_or(frange.range)
+    let parse = db.parse(frange.file_id);
+    try_extend_selection(parse.tree().syntax(), frange.range).unwrap_or(frange.range)
 }
 
 fn try_extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange> {
@@ -212,10 +212,10 @@ mod tests {
 
     fn do_check(before: &str, afters: &[&str]) {
         let (cursor, before) = extract_offset(before);
-        let file = SourceFile::parse(&before).tree;
+        let parse = SourceFile::parse(&before);
         let mut range = TextRange::offset_len(cursor, 0.into());
         for &after in afters {
-            range = try_extend_selection(file.syntax(), range).unwrap();
+            range = try_extend_selection(parse.tree().syntax(), range).unwrap();
             let actual = &before[range];
             assert_eq!(after, actual);
         }
diff --git a/crates/ra_ide_api/src/folding_ranges.rs b/crates/ra_ide_api/src/folding_ranges.rs
@@ -192,8 +192,8 @@ mod tests {
 
     fn do_check(text: &str, fold_kinds: &[FoldKind]) {
         let (ranges, text) = extract_ranges(text, "fold");
-        let file = SourceFile::parse(&text).tree;
-        let folds = folding_ranges(&file);
+        let parse = SourceFile::parse(&text);
+        let folds = folding_ranges(parse.tree());
 
         assert_eq!(
             folds.len(),
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
@@ -19,8 +19,8 @@ pub(crate) fn goto_definition(
     db: &RootDatabase,
     position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let file = db.parse(position.file_id).tree;
-    let syntax = file.syntax();
+    let parse = db.parse(position.file_id);
+    let syntax = parse.tree().syntax();
     if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
         let navs = reference_definition(db, position.file_id, name_ref).to_vec();
         return Some(RangeInfo::new(name_ref.syntax().range(), navs.to_vec()));
diff --git a/crates/ra_ide_api/src/goto_type_definition.rs b/crates/ra_ide_api/src/goto_type_definition.rs
@@ -7,9 +7,9 @@ pub(crate) fn goto_type_definition(
     db: &RootDatabase,
     position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let file = db.parse(position.file_id).tree;
+    let parse = db.parse(position.file_id);
 
-    let node = find_token_at_offset(file.syntax(), position.offset).find_map(|token| {
+    let node = find_token_at_offset(parse.tree().syntax(), position.offset).find_map(|token| {
         token
             .parent()
             .ancestors()
diff --git a/crates/ra_ide_api/src/hover.rs b/crates/ra_ide_api/src/hover.rs
@@ -94,7 +94,8 @@ fn hover_text(docs: Option<String>, desc: Option<String>) -> Option<String> {
 }
 
 pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
-    let file = db.parse(position.file_id).tree;
+    let parse = db.parse(position.file_id);
+    let file = parse.tree();
     let mut res = HoverResult::new();
 
     let mut range = None;
@@ -241,8 +242,8 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
 }
 
 pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
-    let file = db.parse(frange.file_id).tree;
-    let syntax = file.syntax();
+    let parse = db.parse(frange.file_id);
+    let syntax = parse.tree().syntax();
     let leaf_node = find_covering_element(syntax, frange.range);
     // if we picked identifier, expand to pattern/expression
     let node = leaf_node
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
@@ -8,8 +8,8 @@ pub(crate) fn goto_implementation(
     db: &RootDatabase,
     position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
-    let file = db.parse(position.file_id).tree;
-    let syntax = file.syntax();
+    let parse = db.parse(position.file_id);
+    let syntax = parse.tree().syntax();
 
     let module = source_binder::module_from_position(db, position)?;
 
diff --git a/crates/ra_ide_api/src/join_lines.rs b/crates/ra_ide_api/src/join_lines.rs
@@ -503,8 +503,8 @@ fn foo() {
 
     fn check_join_lines_sel(before: &str, after: &str) {
         let (sel, before) = extract_range(before);
-        let file = SourceFile::parse(&before).tree;
-        let result = join_lines(&file, sel);
+        let parse = SourceFile::parse(&before);
+        let result = join_lines(parse.tree(), sel);
         let actual = result.apply(&before);
         assert_eq_text!(after, &actual);
     }
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
@@ -326,7 +326,7 @@ impl Analysis {
 
     /// Gets the syntax tree of the file.
     pub fn parse(&self, file_id: FileId) -> TreeArc<SourceFile> {
-        self.db.parse(file_id).tree
+        self.db.parse(file_id).tree().to_owned()
     }
 
     /// Gets the file's `LineIndex`: data structure to convert between absolute
@@ -343,7 +343,8 @@ impl Analysis {
     /// Returns position of the matching brace (all types of braces are
     /// supported).
     pub fn matching_brace(&self, position: FilePosition) -> Option<TextUnit> {
-        let file = self.db.parse(position.file_id).tree;
+        let parse = self.db.parse(position.file_id);
+        let file = parse.tree();
         matching_brace::matching_brace(&file, position.offset)
     }
 
@@ -356,10 +357,10 @@ impl Analysis {
     /// Returns an edit to remove all newlines in the range, cleaning up minor
     /// stuff like trailing commas.
     pub fn join_lines(&self, frange: FileRange) -> SourceChange {
-        let file = self.db.parse(frange.file_id).tree;
+        let parse = self.db.parse(frange.file_id);
         let file_edit = SourceFileEdit {
             file_id: frange.file_id,
-            edit: join_lines::join_lines(&file, frange.range),
+            edit: join_lines::join_lines(parse.tree(), frange.range),
         };
         SourceChange::source_file_edit("join lines", file_edit)
     }
@@ -374,7 +375,8 @@ impl Analysis {
     /// this works when adding `let =`.
     // FIXME: use a snippet completion instead of this hack here.
     pub fn on_eq_typed(&self, position: FilePosition) -> Option<SourceChange> {
-        let file = self.db.parse(position.file_id).tree;
+        let parse = self.db.parse(position.file_id);
+        let file = parse.tree();
         let edit = typing::on_eq_typed(&file, position.offset)?;
         Some(SourceChange::source_file_edit(
             "add semicolon",
@@ -390,14 +392,14 @@ impl Analysis {
     /// Returns a tree representation of symbols in the file. Useful to draw a
     /// file outline.
     pub fn file_structure(&self, file_id: FileId) -> Vec<StructureNode> {
-        let file = self.db.parse(file_id).tree;
-        file_structure(&file)
+        let parse = self.db.parse(file_id);
+        file_structure(parse.tree())
     }
 
     /// Returns the set of folding ranges.
     pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
-        let file = self.db.parse(file_id).tree;
-        folding_ranges::folding_ranges(&file)
+        let parse = self.db.parse(file_id);
+        folding_ranges::folding_ranges(parse.tree())
     }
 
     /// Fuzzy searches for a symbol.
diff --git a/crates/ra_ide_api/src/matching_brace.rs b/crates/ra_ide_api/src/matching_brace.rs
@@ -25,8 +25,8 @@ mod tests {
     fn test_matching_brace() {
         fn do_check(before: &str, after: &str) {
             let (pos, before) = extract_offset(before);
-            let file = SourceFile::parse(&before).tree;
-            let new_pos = match matching_brace(&file, pos) {
+            let parse = SourceFile::parse(&before);
+            let new_pos = match matching_brace(parse.tree(), pos) {
                 None => pos,
                 Some(pos) => pos,
             };
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
@@ -49,8 +49,8 @@ pub(crate) fn find_all_refs(
     db: &RootDatabase,
     position: FilePosition,
 ) -> Option<ReferenceSearchResult> {
-    let file = db.parse(position.file_id).tree;
-    let (binding, analyzer) = find_binding(db, &file, position)?;
+    let parse = db.parse(position.file_id);
+    let (binding, analyzer) = find_binding(db, parse.tree(), position)?;
     let declaration = NavigationTarget::from_bind_pat(position.file_id, binding);
 
     let references = analyzer
@@ -88,8 +88,8 @@ pub(crate) fn rename(
     position: FilePosition,
     new_name: &str,
 ) -> Option<SourceChange> {
-    let source_file = db.parse(position.file_id).tree;
-    let syntax = source_file.syntax();
+    let parse = db.parse(position.file_id);
+    let syntax = parse.tree().syntax();
 
     if let Some((ast_name, ast_module)) = find_name_and_module_at_offset(syntax, position) {
         rename_mod(db, ast_name, ast_module, position, new_name)
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
diff --git a/crates/ra_ide_api/src/status.rs b/crates/ra_ide_api/src/status.rs
diff --git a/crates/ra_ide_api/src/symbol_index.rs b/crates/ra_ide_api/src/symbol_index.rs
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
diff --git a/crates/ra_ide_api/src/syntax_tree.rs b/crates/ra_ide_api/src/syntax_tree.rs
diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
diff --git a/crates/ra_syntax/tests/test.rs b/crates/ra_syntax/tests/test.rs

Original file line number	Diff line number	Diff line change
`@@ -71,11 +71,11 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {`
`71`	`71`	`where`
`72`	`72`	`F: FnOnce(AssistCtx<DB>) -> T,`
`73`	`73`	`{`
`74`		`- let source_file = &db.parse(frange.file_id).tree;`
	`74`	`+ let parse = db.parse(frange.file_id);`
`75`	`75`	`let assist =`
`76`	`76`	`if should_compute_edit { Assist::Resolved(vec![]) } else { Assist::Unresolved(vec![]) };`
`77`	`77`
`78`		`- let ctx = AssistCtx { db, frange, source_file, should_compute_edit, assist };`
	`78`	`+ let ctx = AssistCtx { db, frange, source_file: parse.tree(), should_compute_edit, assist };`
`79`	`79`	`f(ctx)`
`80`	`80`	`}`
`81`	`81`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ fn main() -> Result<()> {`
`102`	`102`
`103`	`103`	`fn file() -> Result<TreeArc<SourceFile>> {`
`104`	`104`	`let text = read_stdin()?;`
`105`		`- Ok(SourceFile::parse(&text).tree)`
	`105`	`+ Ok(SourceFile::parse(&text).tree().to_owned())`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`fn read_stdin() -> Result<String> {`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ impl ModuleSource {`
`167`	`167`	`) -> ModuleSource {`
`168`	`168`	`match (file_id, decl_id) {`
`169`	`169`	`(Some(file_id), _) => {`
`170`		`- let source_file = db.parse(file_id).tree;`
	`170`	`+ let source_file = db.parse(file_id).tree().to_owned();`
`171`	`171`	`ModuleSource::SourceFile(source_file)`
`172`	`172`	`}`
`173`	`173`	`(None, Some(item_id)) => {`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ impl HirFileId {`
`60`	`60`	`file_id: HirFileId,`
`61`	`61`	`) -> Option<TreeArc<SyntaxNode>> {`
`62`	`62`	`match file_id.0 {`
`63`		`- HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree.syntax().to_owned()),`
	`63`	`+ HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().to_owned()),`
`64`	`64`	`HirFileIdRepr::Macro(macro_file) => db.parse_macro(macro_file),`
`65`	`65`	`}`
`66`	`66`	`}`