//! Transforms syntax into `Path` objects, ideally with accounting for hygiene mod lower_use; use std::sync::Arc; use either::Either; use hir_expand::{ hygiene::Hygiene, name::{name, AsName}, }; use ra_syntax::ast::{self, AstNode, TypeAscriptionOwner, TypeBoundsOwner}; use super::AssociatedTypeBinding; use crate::{ body::LowerCtx, path::{GenericArg, GenericArgs, ModPath, Path, PathKind}, type_ref::{TypeBound, TypeRef}, }; pub(super) use lower_use::lower_use_tree; /// Converts an `ast::Path` to `Path`. Works with use trees. /// It correctly handles `$crate` based path from macro call. pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> { let mut kind = PathKind::Plain; let mut type_anchor = None; let mut segments = Vec::new(); let mut generic_args = Vec::new(); let ctx = LowerCtx::with_hygiene(hygiene); loop { let segment = path.segment()?; if segment.coloncolon_token().is_some() { kind = PathKind::Abs; } match segment.kind()? { ast::PathSegmentKind::Name(name_ref) => { // FIXME: this should just return name match hygiene.name_ref_to_name(name_ref) { Either::Left(name) => { let args = segment .type_arg_list() .and_then(|it| lower_generic_args(&ctx, it)) .or_else(|| { lower_generic_args_from_fn_path( &ctx, segment.param_list(), segment.ret_type(), ) }) .map(Arc::new); segments.push(name); generic_args.push(args) } Either::Right(crate_id) => { kind = PathKind::DollarCrate(crate_id); break; } } } ast::PathSegmentKind::Type { type_ref, trait_ref } => { assert!(path.qualifier().is_none()); // this can only occur at the first segment let self_type = TypeRef::from_ast(&ctx, type_ref?); match trait_ref { // <T>::foo None => { type_anchor = Some(Box::new(self_type)); kind = PathKind::Plain; } // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo Some(trait_ref) => { let path = Path::from_src(trait_ref.path()?, hygiene)?; kind = path.mod_path.kind; let mut prefix_segments = path.mod_path.segments; prefix_segments.reverse(); segments.extend(prefix_segments); let mut prefix_args = path.generic_args; prefix_args.reverse(); generic_args.extend(prefix_args); // Insert the type reference (T in the above example) as Self parameter for the trait let last_segment = generic_args.last_mut()?; if last_segment.is_none() { *last_segment = Some(Arc::new(GenericArgs::empty())); }; let args = last_segment.as_mut().unwrap(); let mut args_inner = Arc::make_mut(args); args_inner.has_self_type = true; args_inner.args.insert(0, GenericArg::Type(self_type)); } } } ast::PathSegmentKind::CrateKw => { kind = PathKind::Crate; break; } ast::PathSegmentKind::SelfKw => { kind = PathKind::Super(0); break; } ast::PathSegmentKind::SuperKw => { let nested_super_count = if let PathKind::Super(n) = kind { n } else { 0 }; kind = PathKind::Super(nested_super_count + 1); } } path = match qualifier(&path) { Some(it) => it, None => break, }; } segments.reverse(); generic_args.reverse(); // handle local_inner_macros : // Basically, even in rustc it is quite hacky: // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456 // We follow what it did anyway :) if segments.len() == 1 && kind == PathKind::Plain { if let Some(macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) { if macro_call.is_bang() { if let Some(crate_id) = hygiene.local_inner_macros() { kind = PathKind::DollarCrate(crate_id); } } } } let mod_path = ModPath { kind, segments }; return Some(Path { type_anchor, mod_path, generic_args }); fn qualifier(path: &ast::Path) -> Option<ast::Path> { if let Some(q) = path.qualifier() { return Some(q); } // FIXME: this bottom up traversal is not too precise. // Should we handle do a top-down analysis, recording results? let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?; let use_tree = use_tree_list.parent_use_tree(); use_tree.path() } } pub(super) fn lower_generic_args( lower_ctx: &LowerCtx, node: ast::TypeArgList, ) -> Option<GenericArgs> { let mut args = Vec::new(); for type_arg in node.type_args() { let type_ref = TypeRef::from_ast_opt(lower_ctx, type_arg.type_ref()); args.push(GenericArg::Type(type_ref)); } // lifetimes ignored for now let mut bindings = Vec::new(); for assoc_type_arg in node.assoc_type_args() { let assoc_type_arg: ast::AssocTypeArg = assoc_type_arg; if let Some(name_ref) = assoc_type_arg.name_ref() { let name = name_ref.as_name(); let type_ref = assoc_type_arg.type_ref().map(|it| TypeRef::from_ast(lower_ctx, it)); let bounds = if let Some(l) = assoc_type_arg.type_bound_list() { l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect() } else { Vec::new() }; bindings.push(AssociatedTypeBinding { name, type_ref, bounds }); } } if args.is_empty() && bindings.is_empty() { None } else { Some(GenericArgs { args, has_self_type: false, bindings }) } } /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y) /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`). fn lower_generic_args_from_fn_path( ctx: &LowerCtx, params: Option<ast::ParamList>, ret_type: Option<ast::RetType>, ) -> Option<GenericArgs> { let mut args = Vec::new(); let mut bindings = Vec::new(); if let Some(params) = params { let mut param_types = Vec::new(); for param in params.params() { let type_ref = TypeRef::from_ast_opt(&ctx, param.ascribed_type()); param_types.push(type_ref); } let arg = GenericArg::Type(TypeRef::Tuple(param_types)); args.push(arg); } if let Some(ret_type) = ret_type { let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.type_ref()); bindings.push(AssociatedTypeBinding { name: name![Output], type_ref: Some(type_ref), bounds: Vec::new(), }); } if args.is_empty() && bindings.is_empty() { None } else { Some(GenericArgs { args, has_self_type: false, bindings }) } }