From e2b28f5bb8043e92b10f6a40696131007fc9dfe2 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 19 Jul 2019 10:43:01 +0300 Subject: migrate ra_hir to the new rowan --- crates/ra_hir/src/adt.rs | 15 ++++------ crates/ra_hir/src/code_model.rs | 19 ++++++------- crates/ra_hir/src/code_model/docs.rs | 24 ++++++++-------- crates/ra_hir/src/code_model/src.rs | 44 ++++++++++++++--------------- crates/ra_hir/src/db.rs | 6 ++-- crates/ra_hir/src/diagnostics.rs | 12 ++++---- crates/ra_hir/src/expr.rs | 46 +++++++++++++++--------------- crates/ra_hir/src/expr/scope.rs | 6 ++-- crates/ra_hir/src/expr/validation.rs | 2 +- crates/ra_hir/src/generics.rs | 22 +++++++-------- crates/ra_hir/src/ids.rs | 14 +++++----- crates/ra_hir/src/impl_block.rs | 24 ++++++++-------- crates/ra_hir/src/lang_item.rs | 8 +++--- crates/ra_hir/src/name.rs | 2 +- crates/ra_hir/src/nameres/raw.rs | 52 +++++++++++++++++----------------- crates/ra_hir/src/path.rs | 26 ++++++++--------- crates/ra_hir/src/source_binder.rs | 54 ++++++++++++++++++------------------ crates/ra_hir/src/source_id.rs | 18 ++++++------ crates/ra_hir/src/traits.rs | 6 ++-- crates/ra_hir/src/ty/tests.rs | 10 +++---- crates/ra_hir/src/type_ref.rs | 4 +-- 21 files changed, 205 insertions(+), 209 deletions(-) (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs index 8afdac801..c65446df4 100644 --- a/crates/ra_hir/src/adt.rs +++ b/crates/ra_hir/src/adt.rs @@ -4,10 +4,7 @@ use std::sync::Arc; use ra_arena::{impl_arena_id, Arena, RawId}; -use ra_syntax::{ - ast::{self, NameOwner, StructKind, TypeAscriptionOwner}, - TreeArc, -}; +use ra_syntax::ast::{self, NameOwner, StructKind, TypeAscriptionOwner}; use crate::{ type_ref::TypeRef, AsName, AstDatabase, Crate, DefDatabase, Enum, EnumVariant, FieldSource, @@ -59,11 +56,11 @@ impl StructData { struct_: Struct, ) -> Arc { let src = struct_.source(db); - Arc::new(StructData::new(&*src.ast)) + Arc::new(StructData::new(&src.ast)) } } -fn variants(enum_def: &ast::EnumDef) -> impl Iterator { +fn variants(enum_def: &ast::EnumDef) -> impl Iterator { enum_def.variant_list().into_iter().flat_map(|it| it.variants()) } @@ -71,9 +68,9 @@ impl EnumVariant { pub(crate) fn source_impl( self, db: &(impl DefDatabase + AstDatabase), - ) -> Source> { + ) -> Source { let src = self.parent.source(db); - let ast = variants(&*src.ast) + let ast = variants(&src.ast) .zip(db.enum_data(self.parent).variants.iter()) .find(|(_syntax, (id, _))| *id == self.id) .unwrap() @@ -96,7 +93,7 @@ impl EnumData { pub(crate) fn enum_data_query(db: &(impl DefDatabase + AstDatabase), e: Enum) -> Arc { let src = e.source(db); let name = src.ast.name().map(|n| n.as_name()); - let variants = variants(&*src.ast) + let variants = variants(&src.ast) .map(|var| EnumVariantData { name: var.name().map(|it| it.as_name()), variant_data: Arc::new(VariantData::new(var.kind())), diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 4fb5844f4..779764590 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -4,10 +4,7 @@ pub(crate) mod docs; use std::sync::Arc; use ra_db::{CrateId, Edition, FileId, SourceRootId}; -use ra_syntax::{ - ast::{self, NameOwner, TypeAscriptionOwner}, - TreeArc, -}; +use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; use crate::{ adt::{EnumVariantId, StructFieldId, VariantDef}, @@ -155,8 +152,8 @@ impl_froms!( ); pub enum ModuleSource { - SourceFile(TreeArc), - Module(TreeArc), + SourceFile(ast::SourceFile), + Module(ast::Module), } impl ModuleSource { @@ -199,7 +196,7 @@ impl Module { self, db: &impl HirDatabase, import: ImportId, - ) -> Either, TreeArc> { + ) -> Either { let src = self.definition_source(db); let (_, source_map) = db.raw_items_with_source_map(src.file_id); source_map.get(&src.ast, import) @@ -321,8 +318,8 @@ pub struct StructField { #[derive(Debug)] pub enum FieldSource { - Named(TreeArc), - Pos(TreeArc), + Named(ast::NamedFieldDef), + Pos(ast::PosFieldDef), } impl StructField { @@ -736,7 +733,7 @@ impl ConstData { konst: Const, ) -> Arc { let node = konst.source(db).ast; - const_data_for(&*node) + const_data_for(&node) } pub(crate) fn static_data_query( @@ -744,7 +741,7 @@ impl ConstData { konst: Static, ) -> Arc { let node = konst.source(db).ast; - const_data_for(&*node) + const_data_for(&node) } } diff --git a/crates/ra_hir/src/code_model/docs.rs b/crates/ra_hir/src/code_model/docs.rs index 007ef315d..a2b4d8e97 100644 --- a/crates/ra_hir/src/code_model/docs.rs +++ b/crates/ra_hir/src/code_model/docs.rs @@ -71,21 +71,21 @@ pub(crate) fn documentation_query( def: DocDef, ) -> Option { match def { - DocDef::Module(it) => docs_from_ast(&*it.declaration_source(db)?.ast), + DocDef::Module(it) => docs_from_ast(&it.declaration_source(db)?.ast), DocDef::StructField(it) => match it.source(db).ast { - FieldSource::Named(named) => docs_from_ast(&*named), + FieldSource::Named(named) => docs_from_ast(&named), FieldSource::Pos(..) => None, }, - DocDef::Struct(it) => docs_from_ast(&*it.source(db).ast), - DocDef::Enum(it) => docs_from_ast(&*it.source(db).ast), - DocDef::EnumVariant(it) => docs_from_ast(&*it.source(db).ast), - DocDef::Static(it) => docs_from_ast(&*it.source(db).ast), - DocDef::Const(it) => docs_from_ast(&*it.source(db).ast), - DocDef::Function(it) => docs_from_ast(&*it.source(db).ast), - DocDef::Union(it) => docs_from_ast(&*it.source(db).ast), - DocDef::Trait(it) => docs_from_ast(&*it.source(db).ast), - DocDef::TypeAlias(it) => docs_from_ast(&*it.source(db).ast), - DocDef::MacroDef(it) => docs_from_ast(&*it.source(db).ast), + DocDef::Struct(it) => docs_from_ast(&it.source(db).ast), + DocDef::Enum(it) => docs_from_ast(&it.source(db).ast), + DocDef::EnumVariant(it) => docs_from_ast(&it.source(db).ast), + DocDef::Static(it) => docs_from_ast(&it.source(db).ast), + DocDef::Const(it) => docs_from_ast(&it.source(db).ast), + DocDef::Function(it) => docs_from_ast(&it.source(db).ast), + DocDef::Union(it) => docs_from_ast(&it.source(db).ast), + DocDef::Trait(it) => docs_from_ast(&it.source(db).ast), + DocDef::TypeAlias(it) => docs_from_ast(&it.source(db).ast), + DocDef::MacroDef(it) => docs_from_ast(&it.source(db).ast), } } diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs index 72451e0e7..32bd9c661 100644 --- a/crates/ra_hir/src/code_model/src.rs +++ b/crates/ra_hir/src/code_model/src.rs @@ -1,4 +1,4 @@ -use ra_syntax::{ast, TreeArc}; +use ra_syntax::ast; use crate::{ ids::AstItemDef, AstDatabase, Const, DefDatabase, Enum, EnumVariant, FieldSource, Function, @@ -34,7 +34,7 @@ impl Module { pub fn declaration_source( self, db: &(impl DefDatabase + AstDatabase), - ) -> Option>> { + ) -> Option> { let def_map = db.crate_def_map(self.krate); let decl = def_map[self.module_id].declaration?; let ast = decl.to_node(db); @@ -49,62 +49,62 @@ impl HasSource for StructField { } } impl HasSource for Struct { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::StructDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for Union { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::StructDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for Enum { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::EnumDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for EnumVariant { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::EnumVariant; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.source_impl(db) } } impl HasSource for Function { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::FnDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for Const { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::ConstDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for Static { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::StaticDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for Trait { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::TraitDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for TypeAlias { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::TypeAliasDef; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { self.id.source(db) } } impl HasSource for MacroDef { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::MacroCall; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { Source { file_id: self.id.0.file_id(), ast: self.id.0.to_node(db) } } } diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index da9f3e32d..358365176 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -2,7 +2,7 @@ use std::sync::Arc; use parking_lot::Mutex; use ra_db::{salsa, SourceDatabase}; -use ra_syntax::{ast, Parse, SmolStr, SyntaxNode, TreeArc}; +use ra_syntax::{ast, Parse, SmolStr, SyntaxNode}; use crate::{ adt::{EnumData, StructData}, @@ -62,11 +62,11 @@ pub trait AstDatabase: InternDatabase { #[salsa::transparent] #[salsa::invoke(crate::source_id::AstIdMap::file_item_query)] - fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> TreeArc; + fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode; #[salsa::transparent] #[salsa::invoke(crate::ids::HirFileId::parse_or_expand_query)] - fn parse_or_expand(&self, file_id: HirFileId) -> Option>; + fn parse_or_expand(&self, file_id: HirFileId) -> Option; #[salsa::invoke(crate::ids::HirFileId::parse_macro_query)] fn parse_macro(&self, macro_file: ids::MacroFile) -> Option>; diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs index c97f0656d..0290483b3 100644 --- a/crates/ra_hir/src/diagnostics.rs +++ b/crates/ra_hir/src/diagnostics.rs @@ -1,6 +1,6 @@ use std::{any::Any, fmt}; -use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange, TreeArc}; +use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange}; use relative_path::RelativePathBuf; use crate::{HirDatabase, HirFileId, Name}; @@ -33,9 +33,9 @@ pub trait AstDiagnostic { } impl dyn Diagnostic { - pub fn syntax_node(&self, db: &impl HirDatabase) -> TreeArc { + pub fn syntax_node(&self, db: &impl HirDatabase) -> SyntaxNode { let node = db.parse_or_expand(self.file()).unwrap(); - self.syntax_node_ptr().to_node(&*node).to_owned() + self.syntax_node_ptr().to_node(&node) } pub fn downcast_ref(&self) -> Option<&D> { @@ -143,11 +143,11 @@ impl Diagnostic for MissingFields { } impl AstDiagnostic for MissingFields { - type AST = TreeArc; + type AST = ast::NamedFieldList; fn ast(&self, db: &impl HirDatabase) -> Self::AST { let root = db.parse_or_expand(self.file()).unwrap(); - let node = self.syntax_node_ptr().to_node(&*root); - ast::NamedFieldList::cast(&node).unwrap().to_owned() + let node = self.syntax_node_ptr().to_node(&root); + ast::NamedFieldList::cast(node).unwrap() } } diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index 3a97d97ce..70af3f119 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs @@ -550,7 +550,7 @@ where self.exprs.alloc(block) } - fn collect_expr(&mut self, expr: &ast::Expr) -> ExprId { + fn collect_expr(&mut self, expr: ast::Expr) -> ExprId { let syntax_ptr = SyntaxNodePtr::new(expr.syntax()); match expr.kind() { ast::ExprKind::IfExpr(e) => { @@ -565,7 +565,8 @@ where .map(|b| match b { ast::ElseBranch::Block(it) => self.collect_block(it), ast::ElseBranch::IfExpr(elif) => { - let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap(); + let expr: ast::Expr = + ast::Expr::cast(elif.syntax().clone()).unwrap(); self.collect_expr(expr) } }) @@ -582,7 +583,7 @@ where let else_branch = e.else_branch().map(|b| match b { ast::ElseBranch::Block(it) => self.collect_block(it), ast::ElseBranch::IfExpr(elif) => { - let expr: &ast::Expr = ast::Expr::cast(elif.syntax()).unwrap(); + let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap(); self.collect_expr(expr) } }); @@ -689,7 +690,7 @@ where let struct_lit = if let Some(nfl) = e.named_field_list() { let fields = nfl .fields() - .inspect(|field| field_ptrs.push(AstPtr::new(*field))) + .inspect(|field| field_ptrs.push(AstPtr::new(field))) .map(|field| StructLitField { name: field .name_ref() @@ -699,7 +700,7 @@ where self.collect_expr(e) } else if let Some(nr) = field.name_ref() { // field shorthand - let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(nr))); + let id = self.exprs.alloc(Expr::Path(Path::from_name_ref(&nr))); self.source_map .expr_map .insert(SyntaxNodePtr::new(nr.syntax()), id); @@ -837,7 +838,7 @@ where let ast_id = self .db .ast_id_map(self.current_file_id) - .ast_id(e) + .ast_id(&e) .with_file_id(self.current_file_id); if let Some(path) = e.path().and_then(Path::from_ast) { @@ -845,11 +846,11 @@ where let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db); let file_id = call_id.as_file(MacroFileKind::Expr); if let Some(node) = self.db.parse_or_expand(file_id) { - if let Some(expr) = ast::Expr::cast(&*node) { + if let Some(expr) = ast::Expr::cast(node) { log::debug!("macro expansion {}", expr.syntax().debug_dump()); let old_file_id = std::mem::replace(&mut self.current_file_id, file_id); - let id = self.collect_expr(&expr); + let id = self.collect_expr(expr); self.current_file_id = old_file_id; return id; } @@ -863,7 +864,7 @@ where } } - fn collect_expr_opt(&mut self, expr: Option<&ast::Expr>) -> ExprId { + fn collect_expr_opt(&mut self, expr: Option) -> ExprId { if let Some(expr) = expr { self.collect_expr(expr) } else { @@ -871,7 +872,7 @@ where } } - fn collect_block(&mut self, block: &ast::Block) -> ExprId { + fn collect_block(&mut self, block: ast::Block) -> ExprId { let statements = block .statements() .map(|s| match s.kind() { @@ -890,7 +891,7 @@ where self.alloc_expr(Expr::Block { statements, tail }, SyntaxNodePtr::new(block.syntax())) } - fn collect_block_opt(&mut self, block: Option<&ast::Block>) -> ExprId { + fn collect_block_opt(&mut self, block: Option) -> ExprId { if let Some(block) = block { self.collect_block(block) } else { @@ -898,7 +899,7 @@ where } } - fn collect_pat(&mut self, pat: &ast::Pat) -> PatId { + fn collect_pat(&mut self, pat: ast::Pat) -> PatId { let pattern = match pat.kind() { ast::PatKind::BindPat(bp) => { let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing); @@ -932,7 +933,8 @@ where let mut fields: Vec<_> = field_pat_list .bind_pats() .filter_map(|bind_pat| { - let ast_pat = ast::Pat::cast(bind_pat.syntax()).expect("bind pat is a pat"); + let ast_pat = + ast::Pat::cast(bind_pat.syntax().clone()).expect("bind pat is a pat"); let pat = self.collect_pat(ast_pat); let name = bind_pat.name()?.as_name(); Some(FieldPat { name, pat }) @@ -953,11 +955,11 @@ where ast::PatKind::LiteralPat(_) => Pat::Missing, ast::PatKind::SlicePat(_) | ast::PatKind::RangePat(_) => Pat::Missing, }; - let ptr = AstPtr::new(pat); + let ptr = AstPtr::new(&pat); self.alloc_pat(pattern, Either::A(ptr)) } - fn collect_pat_opt(&mut self, pat: Option<&ast::Pat>) -> PatId { + fn collect_pat_opt(&mut self, pat: Option) -> PatId { if let Some(pat) = pat { self.collect_pat(pat) } else { @@ -965,20 +967,20 @@ where } } - fn collect_const_body(&mut self, node: &ast::ConstDef) { + fn collect_const_body(&mut self, node: ast::ConstDef) { let body = self.collect_expr_opt(node.body()); self.body_expr = Some(body); } - fn collect_static_body(&mut self, node: &ast::StaticDef) { + fn collect_static_body(&mut self, node: ast::StaticDef) { let body = self.collect_expr_opt(node.body()); self.body_expr = Some(body); } - fn collect_fn_body(&mut self, node: &ast::FnDef) { + fn collect_fn_body(&mut self, node: ast::FnDef) { if let Some(param_list) = node.param_list() { if let Some(self_param) = param_list.self_param() { - let ptr = AstPtr::new(self_param); + let ptr = AstPtr::new(&self_param); let param_pat = self.alloc_pat( Pat::Bind { name: SELF_PARAM, @@ -1027,17 +1029,17 @@ pub(crate) fn body_with_source_map_query( DefWithBody::Const(ref c) => { let src = c.source(db); collector = ExprCollector::new(def, src.file_id, def.resolver(db), db); - collector.collect_const_body(&src.ast) + collector.collect_const_body(src.ast) } DefWithBody::Function(ref f) => { let src = f.source(db); collector = ExprCollector::new(def, src.file_id, def.resolver(db), db); - collector.collect_fn_body(&src.ast) + collector.collect_fn_body(src.ast) } DefWithBody::Static(ref s) => { let src = s.source(db); collector = ExprCollector::new(def, src.file_id, def.resolver(db), db); - collector.collect_static_body(&src.ast) + collector.collect_static_body(src.ast) } } diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs index 28fd52684..6589b782c 100644 --- a/crates/ra_hir/src/expr/scope.rs +++ b/crates/ra_hir/src/expr/scope.rs @@ -190,7 +190,7 @@ mod tests { let (db, _source_root, file_id) = MockDatabase::with_single_file(&code); let file = db.parse(file_id).ok().unwrap(); - let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap(); + let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap(); let analyzer = SourceAnalyzer::new(&db, file_id, marker.syntax(), None); let scopes = analyzer.scopes(); @@ -290,10 +290,10 @@ mod tests { let file = db.parse(file_id).ok().unwrap(); let expected_name = find_node_at_offset::(file.syntax(), expected_offset.into()) .expect("failed to find a name at the target offset"); - let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap(); + let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap(); let analyzer = SourceAnalyzer::new(&db, file_id, name_ref.syntax(), None); - let local_name_entry = analyzer.resolve_local_name(name_ref).unwrap(); + let local_name_entry = analyzer.resolve_local_name(&name_ref).unwrap(); let local_name = local_name_entry.ptr().either(|it| it.syntax_node_ptr(), |it| it.syntax_node_ptr()); assert_eq!(local_name.range(), expected_name.syntax().range()); diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs index c2a10a0b5..82a06ca25 100644 --- a/crates/ra_hir/src/expr/validation.rs +++ b/crates/ra_hir/src/expr/validation.rs @@ -79,7 +79,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> { .and_then(StructLit::cast) .and_then(|lit| lit.named_field_list()) { - let field_list_ptr = AstPtr::new(field_list_node); + let field_list_ptr = AstPtr::new(&field_list_node); self.sink.push(MissingFields { file: file_id, field_list: field_list_ptr, diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs index 07a59193f..bcbb4988d 100644 --- a/crates/ra_hir/src/generics.rs +++ b/crates/ra_hir/src/generics.rs @@ -76,17 +76,17 @@ impl GenericParams { generics.parent_params = parent.map(|p| db.generic_params(p)); let start = generics.parent_params.as_ref().map(|p| p.params.len()).unwrap_or(0) as u32; match def { - GenericDef::Function(it) => generics.fill(&*it.source(db).ast, start), - GenericDef::Struct(it) => generics.fill(&*it.source(db).ast, start), - GenericDef::Union(it) => generics.fill(&*it.source(db).ast, start), - GenericDef::Enum(it) => generics.fill(&*it.source(db).ast, start), + GenericDef::Function(it) => generics.fill(&it.source(db).ast, start), + GenericDef::Struct(it) => generics.fill(&it.source(db).ast, start), + GenericDef::Union(it) => generics.fill(&it.source(db).ast, start), + GenericDef::Enum(it) => generics.fill(&it.source(db).ast, start), GenericDef::Trait(it) => { // traits get the Self type as an implicit first type parameter generics.params.push(GenericParam { idx: start, name: SELF_TYPE, default: None }); - generics.fill(&*it.source(db).ast, start + 1); + generics.fill(&it.source(db).ast, start + 1); } - GenericDef::TypeAlias(it) => generics.fill(&*it.source(db).ast, start), - GenericDef::ImplBlock(it) => generics.fill(&*it.source(db).ast, start), + GenericDef::TypeAlias(it) => generics.fill(&it.source(db).ast, start), + GenericDef::ImplBlock(it) => generics.fill(&it.source(db).ast, start), GenericDef::EnumVariant(_) => {} } @@ -102,9 +102,9 @@ impl GenericParams { } } - fn fill_params(&mut self, params: &ast::TypeParamList, start: u32) { + fn fill_params(&mut self, params: ast::TypeParamList, start: u32) { for (idx, type_param) in params.type_params().enumerate() { - let name = type_param.name().map(AsName::as_name).unwrap_or_else(Name::missing); + let name = type_param.name().map_or_else(Name::missing, |it| it.as_name()); let default = type_param.default_type().and_then(|t| t.path()).and_then(Path::from_ast); let param = GenericParam { idx: idx as u32 + start, name: name.clone(), default }; @@ -121,7 +121,7 @@ impl GenericParams { } } - fn fill_where_predicates(&mut self, where_clause: &ast::WhereClause) { + fn fill_where_predicates(&mut self, where_clause: ast::WhereClause) { for pred in where_clause.predicates() { let type_ref = match pred.type_ref() { Some(type_ref) => type_ref, @@ -134,7 +134,7 @@ impl GenericParams { } } - fn add_where_predicate_from_bound(&mut self, bound: &ast::TypeBound, type_ref: TypeRef) { + fn add_where_predicate_from_bound(&mut self, bound: ast::TypeBound, type_ref: TypeRef) { let path = bound .type_ref() .and_then(|tr| match tr.kind() { diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index 83f5c3f39..05a18eb56 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -6,7 +6,7 @@ use std::{ use mbe::MacroRules; use ra_db::{salsa, FileId}; use ra_prof::profile; -use ra_syntax::{ast, AstNode, Parse, SyntaxNode, TreeArc}; +use ra_syntax::{ast, AstNode, Parse, SyntaxNode}; use crate::{AstDatabase, AstId, DefDatabase, FileAstId, InternDatabase, Module, Source}; @@ -58,11 +58,11 @@ impl HirFileId { pub(crate) fn parse_or_expand_query( db: &impl AstDatabase, file_id: HirFileId, - ) -> Option> { + ) -> Option { 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().clone()), HirFileIdRepr::Macro(macro_file) => { - db.parse_macro(macro_file).map(|it| it.tree().to_owned()) + db.parse_macro(macro_file).map(|it| it.syntax_node()) } } } @@ -123,7 +123,7 @@ pub struct MacroDefId(pub(crate) AstId); pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option> { let macro_call = id.0.to_node(db); let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(arg).or_else(|| { + let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| { log::warn!("fail on macro_def to token tree: {:#?}", arg); None })?; @@ -138,7 +138,7 @@ pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option< let loc = id.loc(db); let macro_call = loc.ast_id.to_node(db); let arg = macro_call.token_tree()?; - let (tt, _) = mbe::ast_to_token_tree(arg)?; + let (tt, _) = mbe::ast_to_token_tree(&arg)?; Some(Arc::new(tt)) } @@ -262,7 +262,7 @@ pub(crate) trait AstItemDef: salsa::InternKey + Clone { let loc = ItemLoc { module: ctx.module, ast_id: ast_id.with_file_id(ctx.file_id) }; Self::intern(ctx.db, loc) } - fn source(self, db: &(impl AstDatabase + DefDatabase)) -> Source> { + fn source(self, db: &(impl AstDatabase + DefDatabase)) -> Source { let loc = self.lookup_intern(db); let ast = loc.ast_id.to_node(db); Source { file_id: loc.ast_id.file_id(), ast } diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index ce134b27a..8e62cf66d 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -4,7 +4,7 @@ use std::sync::Arc; use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId}; use ra_syntax::{ ast::{self, AstNode}, - AstPtr, SourceFile, TreeArc, + AstPtr, SourceFile, }; use crate::{ @@ -28,9 +28,9 @@ impl ImplSourceMap { self.map.insert(impl_id, AstPtr::new(impl_block)) } - pub fn get(&self, source: &ModuleSource, impl_id: ImplId) -> TreeArc { + pub fn get(&self, source: &ModuleSource, impl_id: ImplId) -> ast::ImplBlock { let file = match source { - ModuleSource::SourceFile(file) => &*file, + ModuleSource::SourceFile(file) => file.clone(), ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(), }; @@ -45,8 +45,8 @@ pub struct ImplBlock { } impl HasSource for ImplBlock { - type Ast = TreeArc; - fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source> { + type Ast = ast::ImplBlock; + fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { let source_map = db.impls_in_module_with_source_map(self.module).1; let src = self.module.definition_source(db); Source { file_id: src.file_id, ast: source_map.get(&src.ast, self.impl_id) } @@ -132,9 +132,9 @@ impl ImplData { item_list .impl_items() .map(|item_node| match item_node.kind() { - ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(it) }.into(), - ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(it) }.into(), - ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(it) }.into(), + ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(&it) }.into(), + ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(), + ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(), }) .collect() } else { @@ -202,20 +202,20 @@ impl ModuleImplBlocks { let src = m.module.definition_source(db); let node = match &src.ast { - ModuleSource::SourceFile(node) => node.syntax(), + ModuleSource::SourceFile(node) => node.syntax().clone(), ModuleSource::Module(node) => { - node.item_list().expect("inline module should have item list").syntax() + node.item_list().expect("inline module should have item list").syntax().clone() } }; for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) { - let impl_block = ImplData::from_ast(db, src.file_id, m.module, impl_block_ast); + let impl_block = ImplData::from_ast(db, src.file_id, m.module, &impl_block_ast); let id = m.impls.alloc(impl_block); for &impl_item in &m.impls[id].items { m.impls_by_def.insert(impl_item, id); } - source_map.insert(id, impl_block_ast); + source_map.insert(id, &impl_block_ast); } m diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs index 0443d4d9a..fd6609fb8 100644 --- a/crates/ra_hir/src/lang_item.rs +++ b/crates/ra_hir/src/lang_item.rs @@ -1,7 +1,7 @@ use rustc_hash::FxHashMap; use std::sync::Arc; -use ra_syntax::{ast::AttrsOwner, SmolStr, TreeArc}; +use ra_syntax::{ast::AttrsOwner, SmolStr}; use crate::{ AstDatabase, Crate, DefDatabase, Enum, Function, HasSource, HirDatabase, ImplBlock, Module, @@ -95,7 +95,7 @@ impl LangItems { // Look for impl targets for impl_block in module.impl_blocks(db) { let src = impl_block.source(db); - if let Some(lang_item_name) = lang_item_name(&*src.ast) { + if let Some(lang_item_name) = lang_item_name(&src.ast) { self.items .entry(lang_item_name) .or_insert_with(|| LangItemTarget::ImplBlock(impl_block)); @@ -137,11 +137,11 @@ impl LangItems { item: T, constructor: fn(T) -> LangItemTarget, ) where - T: Copy + HasSource>, + T: Copy + HasSource, N: AttrsOwner, { let node = item.source(db).ast; - if let Some(lang_item_name) = lang_item_name(&*node) { + if let Some(lang_item_name) = lang_item_name(&node) { self.items.entry(lang_item_name).or_insert_with(|| constructor(item)); } } diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs index 40c9d6002..c589f8aba 100644 --- a/crates/ra_hir/src/name.rs +++ b/crates/ra_hir/src/name.rs @@ -75,7 +75,7 @@ impl AsName for ast::Name { } } -impl<'a> AsName for ast::FieldKind<'a> { +impl AsName for ast::FieldKind { fn as_name(&self) -> Name { match self { ast::FieldKind::Name(nr) => nr.as_name(), diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs index 46b2bef5b..8517f3c43 100644 --- a/crates/ra_hir/src/nameres/raw.rs +++ b/crates/ra_hir/src/nameres/raw.rs @@ -3,7 +3,7 @@ use std::{ops::Index, sync::Arc}; use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId}; use ra_syntax::{ ast::{self, AttrsOwner, NameOwner}, - AstNode, AstPtr, SmolStr, SourceFile, TreeArc, + AstNode, AstPtr, SmolStr, SourceFile, }; use test_utils::tested_by; @@ -32,7 +32,7 @@ pub struct ImportSourceMap { } type ImportSourcePtr = Either, AstPtr>; -type ImportSource = Either, TreeArc>; +type ImportSource = Either; impl ImportSourcePtr { fn to_node(self, file: &SourceFile) -> ImportSource { @@ -50,11 +50,11 @@ impl ImportSourceMap { pub(crate) fn get(&self, source: &ModuleSource, import: ImportId) -> ImportSource { let file = match source { - ModuleSource::SourceFile(file) => &*file, + ModuleSource::SourceFile(file) => file.clone(), ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(), }; - self.map[import].to_node(file) + self.map[import].to_node(&file) } } @@ -76,8 +76,8 @@ impl RawItems { source_map: ImportSourceMap::default(), }; if let Some(node) = db.parse_or_expand(file_id) { - if let Some(source_file) = ast::SourceFile::cast(&node) { - collector.process_module(None, &*source_file); + if let Some(source_file) = ast::SourceFile::cast(node) { + collector.process_module(None, source_file); } } (Arc::new(collector.raw_items), Arc::new(collector.source_map)) @@ -188,7 +188,7 @@ struct RawItemsCollector { } impl RawItemsCollector { - fn process_module(&mut self, current_module: Option, body: &impl ast::ModuleItemOwner) { + fn process_module(&mut self, current_module: Option, body: impl ast::ModuleItemOwner) { for item_or_macro in body.items_with_macros() { match item_or_macro { ast::ItemOrMacro::Macro(m) => self.add_macro(current_module, m), @@ -197,7 +197,7 @@ impl RawItemsCollector { } } - fn add_item(&mut self, current_module: Option, item: &ast::ModuleItem) { + fn add_item(&mut self, current_module: Option, item: ast::ModuleItem) { let (kind, name) = match item.kind() { ast::ModuleItemKind::Module(module) => { self.add_module(current_module, module); @@ -216,7 +216,7 @@ impl RawItemsCollector { return; } ast::ModuleItemKind::StructDef(it) => { - let id = self.source_ast_id_map.ast_id(it); + let id = self.source_ast_id_map.ast_id(&it); let name = it.name(); if it.is_union() { (DefKind::Union(id), name) @@ -225,22 +225,22 @@ impl RawItemsCollector { } } ast::ModuleItemKind::EnumDef(it) => { - (DefKind::Enum(self.source_ast_id_map.ast_id(it)), it.name()) + (DefKind::Enum(self.source_ast_id_map.ast_id(&it)), it.name()) } ast::ModuleItemKind::FnDef(it) => { - (DefKind::Function(self.source_ast_id_map.ast_id(it)), it.name()) + (DefKind::Function(self.source_ast_id_map.ast_id(&it)), it.name()) } ast::ModuleItemKind::TraitDef(it) => { - (DefKind::Trait(self.source_ast_id_map.ast_id(it)), it.name()) + (DefKind::Trait(self.source_ast_id_map.ast_id(&it)), it.name()) } ast::ModuleItemKind::TypeAliasDef(it) => { - (DefKind::TypeAlias(self.source_ast_id_map.ast_id(it)), it.name()) + (DefKind::TypeAlias(self.source_ast_id_map.ast_id(&it)), it.name()) } ast::ModuleItemKind::ConstDef(it) => { - (DefKind::Const(self.source_ast_id_map.ast_id(it)), it.name()) + (DefKind::Const(self.source_ast_id_map.ast_id(&it)), it.name()) } ast::ModuleItemKind::StaticDef(it) => { - (DefKind::Static(self.source_ast_id_map.ast_id(it)), it.name()) + (DefKind::Static(self.source_ast_id_map.ast_id(&it)), it.name()) } }; if let Some(name) = name { @@ -250,14 +250,14 @@ impl RawItemsCollector { } } - fn add_module(&mut self, current_module: Option, module: &ast::Module) { + fn add_module(&mut self, current_module: Option, module: ast::Module) { let name = match module.name() { Some(it) => it.as_name(), None => return, }; - let attr_path = extract_mod_path_attribute(module); - let ast_id = self.source_ast_id_map.ast_id(module); + let attr_path = extract_mod_path_attribute(&module); + let ast_id = self.source_ast_id_map.ast_id(&module); if module.has_semi() { let item = self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id, attr_path }); @@ -278,10 +278,10 @@ impl RawItemsCollector { tested_by!(name_res_works_for_broken_modules); } - fn add_use_item(&mut self, current_module: Option, use_item: &ast::UseItem) { + fn add_use_item(&mut self, current_module: Option, use_item: ast::UseItem) { let is_prelude = use_item.has_atom_attr("prelude_import"); - Path::expand_use_item(use_item, |path, use_tree, is_glob, alias| { + Path::expand_use_item(&use_item, |path, use_tree, is_glob, alias| { let import_data = ImportData { path, alias, is_glob, is_prelude, is_extern_crate: false }; self.push_import(current_module, import_data, Either::A(AstPtr::new(use_tree))); @@ -291,11 +291,11 @@ impl RawItemsCollector { fn add_extern_crate_item( &mut self, current_module: Option, - extern_crate: &ast::ExternCrateItem, + extern_crate: ast::ExternCrateItem, ) { if let Some(name_ref) = extern_crate.name_ref() { - let path = Path::from_name_ref(name_ref); - let alias = extern_crate.alias().and_then(|a| a.name()).map(AsName::as_name); + let path = Path::from_name_ref(&name_ref); + let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name()); let import_data = ImportData { path, alias, @@ -303,18 +303,18 @@ impl RawItemsCollector { is_prelude: false, is_extern_crate: true, }; - self.push_import(current_module, import_data, Either::B(AstPtr::new(extern_crate))); + self.push_import(current_module, import_data, Either::B(AstPtr::new(&extern_crate))); } } - fn add_macro(&mut self, current_module: Option, m: &ast::MacroCall) { + fn add_macro(&mut self, current_module: Option, m: ast::MacroCall) { let path = match m.path().and_then(Path::from_ast) { Some(it) => it, _ => return, }; let name = m.name().map(|it| it.as_name()); - let ast_id = self.source_ast_id_map.ast_id(m); + let ast_id = self.source_ast_id_map.ast_id(&m); let export = m.has_atom_attr("macro_export"); let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export }); self.push_item(current_module, RawItem::Macro(m)); diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs index bce9d2d4b..882db7681 100644 --- a/crates/ra_hir/src/path.rs +++ b/crates/ra_hir/src/path.rs @@ -47,9 +47,9 @@ pub enum PathKind { impl Path { /// Calls `cb` with all paths, represented by this use item. - pub fn expand_use_item<'a>( - item: &'a ast::UseItem, - mut cb: impl FnMut(Path, &'a ast::UseTree, bool, Option), + pub fn expand_use_item( + item: &ast::UseItem, + mut cb: impl FnMut(Path, &ast::UseTree, bool, Option), ) { if let Some(tree) = item.use_tree() { expand_use_tree(None, tree, &mut cb); @@ -57,7 +57,7 @@ impl Path { } /// Converts an `ast::Path` to `Path`. Works with use trees. - pub fn from_ast(mut path: &ast::Path) -> Option { + pub fn from_ast(mut path: ast::Path) -> Option { let mut kind = PathKind::Plain; let mut segments = Vec::new(); loop { @@ -87,7 +87,7 @@ impl Path { break; } } - path = match qualifier(path) { + path = match qualifier(&path) { Some(it) => it, None => break, }; @@ -95,7 +95,7 @@ impl Path { segments.reverse(); return Some(Path { kind, segments }); - fn qualifier(path: &ast::Path) -> Option<&ast::Path> { + fn qualifier(path: &ast::Path) -> Option { if let Some(q) = path.qualifier() { return Some(q); } @@ -136,7 +136,7 @@ impl Path { } impl GenericArgs { - pub(crate) fn from_ast(node: &ast::TypeArgList) -> Option { + pub(crate) fn from_ast(node: ast::TypeArgList) -> Option { let mut args = Vec::new(); for type_arg in node.type_args() { let type_ref = TypeRef::from_ast_opt(type_arg.type_ref()); @@ -160,10 +160,10 @@ impl From for Path { } } -fn expand_use_tree<'a>( +fn expand_use_tree( prefix: Option, - tree: &'a ast::UseTree, - cb: &mut impl FnMut(Path, &'a ast::UseTree, bool, Option), + tree: ast::UseTree, + cb: &mut impl FnMut(Path, &ast::UseTree, bool, Option), ) { if let Some(use_tree_list) = tree.use_tree_list() { let prefix = match tree.path() { @@ -188,7 +188,7 @@ fn expand_use_tree<'a>( if let Some(segment) = ast_path.segment() { if segment.kind() == Some(ast::PathSegmentKind::SelfKw) { if let Some(prefix) = prefix { - cb(prefix, tree, false, alias); + cb(prefix, &tree, false, alias); return; } } @@ -196,7 +196,7 @@ fn expand_use_tree<'a>( } if let Some(path) = convert_path(prefix, ast_path) { let is_glob = tree.has_star(); - cb(path, tree, is_glob, alias) + cb(path, &tree, is_glob, alias) } // FIXME: report errors somewhere // We get here if we do @@ -204,7 +204,7 @@ fn expand_use_tree<'a>( } } -fn convert_path(prefix: Option, path: &ast::Path) -> Option { +fn convert_path(prefix: Option, path: ast::Path) -> Option { let prefix = if let Some(qual) = path.qualifier() { Some(convert_path(prefix, qual)?) } else { prefix }; let segment = path.segment()?; diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index 071c1bb18..e7bc4df97 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs @@ -37,7 +37,7 @@ pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Option Option { let parent_module = module_from_file_id(db, file_id); let child_name = decl.name(); @@ -50,8 +50,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 { let parse = db.parse(position.file_id); - match find_node_at_offset::(parse.tree().syntax(), position.offset) { - Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m), + match &find_node_at_offset::(parse.tree().syntax(), position.offset) { + Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m.clone()), _ => module_from_file_id(db, position.file_id), } } @@ -59,12 +59,12 @@ pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Op fn module_from_inline( db: &impl HirDatabase, file_id: FileId, - module: &ast::Module, + module: ast::Module, ) -> Option { assert!(!module.has_semi()); let file_id = file_id.into(); let ast_id_map = db.ast_id_map(file_id); - let item_id = ast_id_map.ast_id(module).with_file_id(file_id); + let item_id = ast_id_map.ast_id(&module).with_file_id(file_id); module_from_source(db, file_id, Some(item_id)) } @@ -127,16 +127,16 @@ fn try_get_resolver_for_node( file_id: FileId, node: &SyntaxNode, ) -> Option { - if let Some(module) = ast::Module::cast(node) { + if let Some(module) = ast::Module::cast(node.clone()) { Some(module_from_declaration(db, file_id, module)?.resolver(db)) - } else if let Some(_) = ast::SourceFile::cast(node) { + } else if let Some(_) = ast::SourceFile::cast(node.clone()) { Some(module_from_source(db, file_id.into(), None)?.resolver(db)) - } else if let Some(s) = ast::StructDef::cast(node) { + } else if let Some(s) = ast::StructDef::cast(node.clone()) { let module = module_from_child_node(db, file_id, s.syntax())?; - Some(struct_from_module(db, module, s).resolver(db)) - } else if let Some(e) = ast::EnumDef::cast(node) { + Some(struct_from_module(db, module, &s).resolver(db)) + } else if let Some(e) = ast::EnumDef::cast(node.clone()) { let module = module_from_child_node(db, file_id, e.syntax())?; - Some(enum_from_module(db, module, e).resolver(db)) + Some(enum_from_module(db, module, &e).resolver(db)) } else if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF { Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db)) } else { @@ -153,14 +153,14 @@ fn def_with_body_from_child_node( let module = module_from_child_node(db, file_id, node)?; let ctx = LocationCtx::new(db, module, file_id.into()); node.ancestors().find_map(|node| { - if let Some(def) = ast::FnDef::cast(node) { - return Some(Function { id: ctx.to_def(def) }.into()); + if let Some(def) = ast::FnDef::cast(node.clone()) { + return Some(Function { id: ctx.to_def(&def) }.into()); } - if let Some(def) = ast::ConstDef::cast(node) { - return Some(Const { id: ctx.to_def(def) }.into()); + if let Some(def) = ast::ConstDef::cast(node.clone()) { + return Some(Const { id: ctx.to_def(&def) }.into()); } - if let Some(def) = ast::StaticDef::cast(node) { - return Some(Static { id: ctx.to_def(def) }.into()); + if let Some(def) = ast::StaticDef::cast(node.clone()) { + return Some(Static { id: ctx.to_def(&def) }.into()); } None }) @@ -237,7 +237,7 @@ impl SourceAnalyzer { SourceAnalyzer { resolver: node .ancestors() - .find_map(|node| try_get_resolver_for_node(db, file_id, node)) + .find_map(|node| try_get_resolver_for_node(db, file_id, &node)) .unwrap_or_default(), body_source_map: None, infer: None, @@ -257,17 +257,17 @@ impl SourceAnalyzer { } pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option { - let expr_id = self.body_source_map.as_ref()?.node_expr(call.into())?; + let expr_id = self.body_source_map.as_ref()?.node_expr(&call.clone().into())?; self.infer.as_ref()?.method_resolution(expr_id) } pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option { - let expr_id = self.body_source_map.as_ref()?.node_expr(field.into())?; + let expr_id = self.body_source_map.as_ref()?.node_expr(&field.clone().into())?; self.infer.as_ref()?.field_resolution(expr_id) } pub fn resolve_variant(&self, struct_lit: &ast::StructLit) -> Option { - let expr_id = self.body_source_map.as_ref()?.node_expr(struct_lit.into())?; + let expr_id = self.body_source_map.as_ref()?.node_expr(&struct_lit.clone().into())?; self.infer.as_ref()?.variant_resolution(expr_id) } @@ -290,18 +290,18 @@ impl SourceAnalyzer { pub fn resolve_path(&self, db: &impl HirDatabase, path: &ast::Path) -> Option { if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) { - let expr_id = self.body_source_map.as_ref()?.node_expr(path_expr.into())?; + let expr_id = self.body_source_map.as_ref()?.node_expr(&path_expr.into())?; if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) { return Some(PathResolution::AssocItem(assoc)); } } if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) { - let pat_id = self.body_source_map.as_ref()?.node_pat(path_pat.into())?; + let pat_id = self.body_source_map.as_ref()?.node_pat(&path_pat.into())?; if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) { return Some(PathResolution::AssocItem(assoc)); } } - let hir_path = crate::Path::from_ast(path)?; + let hir_path = crate::Path::from_ast(path.clone())?; let res = self.resolver.resolve_path_without_assoc_items(db, &hir_path); let res = res.clone().take_types().or_else(|| res.take_values())?; let res = match res { @@ -343,12 +343,12 @@ impl SourceAnalyzer { // FIXME: at least, this should work with any DefWithBody, but ideally // this should be hir-based altogether let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap(); - let ptr = Either::A(AstPtr::new(pat.into())); + let ptr = Either::A(AstPtr::new(&ast::Pat::from(pat.clone()))); fn_def .syntax() .descendants() .filter_map(ast::NameRef::cast) - .filter(|name_ref| match self.resolve_local_name(*name_ref) { + .filter(|name_ref| match self.resolve_local_name(&name_ref) { None => false, Some(entry) => entry.ptr() == ptr, }) @@ -411,7 +411,7 @@ fn scope_for( node: &SyntaxNode, ) -> Option { node.ancestors() - .map(SyntaxNodePtr::new) + .map(|it| SyntaxNodePtr::new(&it)) .filter_map(|ptr| source_map.syntax_expr(ptr)) .find_map(|it| scopes.scope_for(it)) } diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs index 6cdb90141..51cd65dda 100644 --- a/crates/ra_hir/src/source_id.rs +++ b/crates/ra_hir/src/source_id.rs @@ -5,7 +5,7 @@ use std::{ }; use ra_arena::{impl_arena_id, Arena, RawId}; -use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr, TreeArc}; +use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxNodePtr}; use crate::{AstDatabase, HirFileId}; @@ -42,9 +42,9 @@ impl AstId { self.file_id } - pub(crate) fn to_node(&self, db: &impl AstDatabase) -> TreeArc { + pub(crate) fn to_node(&self, db: &impl AstDatabase) -> N { let syntax_node = db.ast_id_to_node(self.file_id, self.file_ast_id.raw); - N::cast(&syntax_node).unwrap().to_owned() + N::cast(syntax_node).unwrap() } } @@ -93,7 +93,7 @@ pub struct AstIdMap { impl AstIdMap { pub(crate) fn ast_id_map_query(db: &impl AstDatabase, file_id: HirFileId) -> Arc { let map = if let Some(node) = db.parse_or_expand(file_id) { - AstIdMap::from_source(&*node) + AstIdMap::from_source(&node) } else { AstIdMap::default() }; @@ -104,9 +104,9 @@ impl AstIdMap { db: &impl AstDatabase, file_id: HirFileId, ast_id: ErasedFileAstId, - ) -> TreeArc { + ) -> SyntaxNode { let node = db.parse_or_expand(file_id).unwrap(); - db.ast_id_map(file_id).arena[ast_id].to_node(&*node).to_owned() + db.ast_id_map(file_id).arena[ast_id].to_node(&node) } pub(crate) fn ast_id(&self, item: &N) -> FileAstId { @@ -131,7 +131,7 @@ impl AstIdMap { // change parent's id. This means that, say, adding a new function to a // trait does not change ids of top-level items, which helps caching. bfs(node, |it| { - if let Some(module_item) = ast::ModuleItem::cast(it) { + if let Some(module_item) = ast::ModuleItem::cast(it.clone()) { res.alloc(module_item.syntax()); } else if let Some(macro_call) = ast::MacroCall::cast(it) { res.alloc(macro_call.syntax()); @@ -146,8 +146,8 @@ impl AstIdMap { } /// Walks the subtree in bfs order, calling `f` for each node. -fn bfs(node: &SyntaxNode, mut f: impl FnMut(&SyntaxNode)) { - let mut curr_layer = vec![node]; +fn bfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode)) { + let mut curr_layer = vec![node.clone()]; let mut next_layer = vec![]; while !curr_layer.is_empty() { curr_layer.drain(..).for_each(|node| { diff --git a/crates/ra_hir/src/traits.rs b/crates/ra_hir/src/traits.rs index fc0368303..de26f1a68 100644 --- a/crates/ra_hir/src/traits.rs +++ b/crates/ra_hir/src/traits.rs @@ -31,9 +31,9 @@ impl TraitData { item_list .impl_items() .map(|item_node| match item_node.kind() { - ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(it) }.into(), - ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(it) }.into(), - ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(it) }.into(), + ast::ImplItemKind::FnDef(it) => Function { id: ctx.to_def(&it) }.into(), + ast::ImplItemKind::ConstDef(it) => Const { id: ctx.to_def(&it) }.into(), + ast::ImplItemKind::TypeAliasDef(it) => TypeAlias { id: ctx.to_def(&it) }.into(), }) .collect() } else { diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs index 2410602a6..265740e54 100644 --- a/crates/ra_hir/src/ty/tests.rs +++ b/crates/ra_hir/src/ty/tests.rs @@ -3086,7 +3086,7 @@ fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String { let file = db.parse(pos.file_id).ok().unwrap(); let expr = algo::find_node_at_offset::(file.syntax(), pos.offset).unwrap(); let analyzer = SourceAnalyzer::new(db, pos.file_id, expr.syntax(), Some(pos.offset)); - let ty = analyzer.type_of(db, expr).unwrap(); + let ty = analyzer.type_of(db, &expr).unwrap(); ty.display(db).to_string() } @@ -3126,7 +3126,7 @@ fn infer(content: &str) -> String { types.sort_by_key(|(ptr, _)| (ptr.range().start(), ptr.range().end())); for (syntax_ptr, ty) in &types { let node = syntax_ptr.to_node(source_file.syntax()); - let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node) { + let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.clone()) { (self_param.self_kw_token().range(), "self".to_string()) } else { (syntax_ptr.range(), node.text().to_string().replace("\n", " ")) @@ -3137,7 +3137,7 @@ fn infer(content: &str) -> String { for node in source_file.syntax().descendants() { if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF { - let analyzer = SourceAnalyzer::new(&db, file_id, node, None); + let analyzer = SourceAnalyzer::new(&db, file_id, &node, None); infer_def(analyzer.inference_result(), analyzer.body_source_map()); } } @@ -3179,7 +3179,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() { let node = algo::find_token_at_offset(file.syntax(), pos.offset).right_biased().unwrap().parent(); let events = db.log_executed(|| { - SourceAnalyzer::new(&db, pos.file_id, node, None); + SourceAnalyzer::new(&db, pos.file_id, &node, None); }); assert!(format!("{:?}", events).contains("infer")) } @@ -3200,7 +3200,7 @@ fn typing_whitespace_inside_a_function_should_not_invalidate_types() { let node = algo::find_token_at_offset(file.syntax(), pos.offset).right_biased().unwrap().parent(); let events = db.log_executed(|| { - SourceAnalyzer::new(&db, pos.file_id, node, None); + SourceAnalyzer::new(&db, pos.file_id, &node, None); }); assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events) } diff --git a/crates/ra_hir/src/type_ref.rs b/crates/ra_hir/src/type_ref.rs index 8aa807648..8536ae44a 100644 --- a/crates/ra_hir/src/type_ref.rs +++ b/crates/ra_hir/src/type_ref.rs @@ -56,7 +56,7 @@ pub enum TypeRef { impl TypeRef { /// Converts an `ast::TypeRef` to a `hir::TypeRef`. - pub(crate) fn from_ast(node: &ast::TypeRef) -> Self { + pub(crate) fn from_ast(node: ast::TypeRef) -> Self { use ra_syntax::ast::TypeRefKind::*; match node.kind() { ParenType(inner) => TypeRef::from_ast_opt(inner.type_ref()), @@ -95,7 +95,7 @@ impl TypeRef { } } - pub(crate) fn from_ast_opt(node: Option<&ast::TypeRef>) -> Self { + pub(crate) fn from_ast_opt(node: Option) -> Self { if let Some(node) = node { TypeRef::from_ast(node) } else { -- cgit v1.2.3