crates/hir_def/src/path/lower.rs

   1 //! Transforms syntax into `Path` objects, ideally with accounting for hygiene
   2
   3 mod lower_use;
   4
   5 use std::sync::Arc;
   6
   7 use either::Either;
   8 use hir_expand::{
   9     hygiene::Hygiene,
  10     name::{name, AsName},
  11 };
  12 use syntax::ast::{self, AstNode, TypeBoundsOwner};
  13
  14 use super::AssociatedTypeBinding;
  15 use crate::{
  16     body::LowerCtx,
  17     path::{GenericArg, GenericArgs, ModPath, Path, PathKind},
  18     type_ref::{LifetimeRef, TypeBound, TypeRef},
  19 };
  20
  21 pub(super) use lower_use::lower_use_tree;
  22
  23 /// Converts an `ast::Path` to `Path`. Works with use trees.
  24 /// It correctly handles `$crate` based path from macro call.
  25 pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
  26     let mut kind = PathKind::Plain;
  27     let mut type_anchor = None;
  28     let mut segments = Vec::new();
  29     let mut generic_args = Vec::new();
  30     let ctx = LowerCtx::with_hygiene(hygiene);
  31     loop {
  32         let segment = path.segment()?;
  33
  34         if segment.coloncolon_token().is_some() {
  35             kind = PathKind::Abs;
  36         }
  37
  38         match segment.kind()? {
  39             ast::PathSegmentKind::Name(name_ref) => {
  40                 // FIXME: this should just return name
  41                 match hygiene.name_ref_to_name(name_ref) {
  42                     Either::Left(name) => {
  43                         let args = segment
  44                             .generic_arg_list()
  45                             .and_then(|it| lower_generic_args(&ctx, it))
  46                             .or_else(|| {
  47                                 lower_generic_args_from_fn_path(
  48                                     &ctx,
  49                                     segment.param_list(),
  50                                     segment.ret_type(),
  51                                 )
  52                             })
  53                             .map(Arc::new);
  54                         segments.push(name);
  55                         generic_args.push(args)
  56                     }
  57                     Either::Right(crate_id) => {
  58                         kind = PathKind::DollarCrate(crate_id);
  59                         break;
  60                     }
  61                 }
  62             }
  63             ast::PathSegmentKind::Type { type_ref, trait_ref } => {
  64                 assert!(path.qualifier().is_none()); // this can only occur at the first segment
  65
  66                 let self_type = TypeRef::from_ast(&ctx, type_ref?);
  67
  68                 match trait_ref {
  69                     // <T>::foo
  70                     None => {
  71                         type_anchor = Some(Box::new(self_type));
  72                         kind = PathKind::Plain;
  73                     }
  74                     // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
  75                     Some(trait_ref) => {
  76                         let path = Path::from_src(trait_ref.path()?, hygiene)?;
  77                         kind = path.mod_path.kind;
  78
  79                         let mut prefix_segments = path.mod_path.segments;
  80                         prefix_segments.reverse();
  81                         segments.extend(prefix_segments);
  82
  83                         let mut prefix_args = path.generic_args;
  84                         prefix_args.reverse();
  85                         generic_args.extend(prefix_args);
  86
  87                         // Insert the type reference (T in the above example) as Self parameter for the trait
  88                         let last_segment = generic_args.last_mut()?;
  89                         if last_segment.is_none() {
  90                             *last_segment = Some(Arc::new(GenericArgs::empty()));
  91                         };
  92                         let args = last_segment.as_mut().unwrap();
  93                         let mut args_inner = Arc::make_mut(args);
  94                         args_inner.has_self_type = true;
  95                         args_inner.args.insert(0, GenericArg::Type(self_type));
  96                     }
  97                 }
  98             }
  99             ast::PathSegmentKind::CrateKw => {
 100                 kind = PathKind::Crate;
 101                 break;
 102             }
 103             ast::PathSegmentKind::SelfKw => {
 104                 kind = PathKind::Super(0);
 105                 break;
 106             }
 107             ast::PathSegmentKind::SuperKw => {
 108                 let nested_super_count = if let PathKind::Super(n) = kind { n } else { 0 };
 109                 kind = PathKind::Super(nested_super_count + 1);
 110             }
 111         }
 112         path = match qualifier(&path) {
 113             Some(it) => it,
 114             None => break,
 115         };
 116     }
 117     segments.reverse();
 118     generic_args.reverse();
 119
 120     // handle local_inner_macros :
 121     // Basically, even in rustc it is quite hacky:
 122     // https://github.com/rust-lang/rust/blob/614f273e9388ddd7804d5cbc80b8865068a3744e/src/librustc_resolve/macros.rs#L456
 123     // We follow what it did anyway :)
 124     if segments.len() == 1 && kind == PathKind::Plain {
 125         if let Some(_macro_call) = path.syntax().parent().and_then(ast::MacroCall::cast) {
 126             if let Some(crate_id) = hygiene.local_inner_macros(path) {
 127                 kind = PathKind::DollarCrate(crate_id);
 128             }
 129         }
 130     }
 131
 132     let mod_path = ModPath::from_segments(kind, segments);
 133     return Some(Path { type_anchor, mod_path, generic_args });
 134
 135     fn qualifier(path: &ast::Path) -> Option<ast::Path> {
 136         if let Some(q) = path.qualifier() {
 137             return Some(q);
 138         }
 139         // FIXME: this bottom up traversal is not too precise.
 140         // Should we handle do a top-down analysis, recording results?
 141         let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
 142         let use_tree = use_tree_list.parent_use_tree();
 143         use_tree.path()
 144     }
 145 }
 146
 147 pub(super) fn lower_generic_args(
 148     lower_ctx: &LowerCtx,
 149     node: ast::GenericArgList,
 150 ) -> Option<GenericArgs> {
 151     let mut args = Vec::new();
 152     let mut bindings = Vec::new();
 153     for generic_arg in node.generic_args() {
 154         match generic_arg {
 155             ast::GenericArg::TypeArg(type_arg) => {
 156                 let type_ref = TypeRef::from_ast_opt(lower_ctx, type_arg.ty());
 157                 args.push(GenericArg::Type(type_ref));
 158             }
 159             ast::GenericArg::AssocTypeArg(assoc_type_arg) => {
 160                 if let Some(name_ref) = assoc_type_arg.name_ref() {
 161                     let name = name_ref.as_name();
 162                     let type_ref = assoc_type_arg.ty().map(|it| TypeRef::from_ast(lower_ctx, it));
 163                     let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
 164                         l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
 165                     } else {
 166                         Vec::new()
 167                     };
 168                     bindings.push(AssociatedTypeBinding { name, type_ref, bounds });
 169                 }
 170             }
 171             ast::GenericArg::LifetimeArg(lifetime_arg) => {
 172                 if let Some(lifetime) = lifetime_arg.lifetime() {
 173                     let lifetime_ref = LifetimeRef::new(&lifetime);
 174                     args.push(GenericArg::Lifetime(lifetime_ref))
 175                 }
 176             }
 177             // constants are ignored for now.
 178             ast::GenericArg::ConstArg(_) => (),
 179         }
 180     }
 181
 182     if args.is_empty() && bindings.is_empty() {
 183         return None;
 184     }
 185     Some(GenericArgs { args, has_self_type: false, bindings })
 186 }
 187
 188 /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
 189 /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
 190 fn lower_generic_args_from_fn_path(
 191     ctx: &LowerCtx,
 192     params: Option<ast::ParamList>,
 193     ret_type: Option<ast::RetType>,
 194 ) -> Option<GenericArgs> {
 195     let mut args = Vec::new();
 196     let mut bindings = Vec::new();
 197     if let Some(params) = params {
 198         let mut param_types = Vec::new();
 199         for param in params.params() {
 200             let type_ref = TypeRef::from_ast_opt(&ctx, param.ty());
 201             param_types.push(type_ref);
 202         }
 203         let arg = GenericArg::Type(TypeRef::Tuple(param_types));
 204         args.push(arg);
 205     }
 206     if let Some(ret_type) = ret_type {
 207         let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.ty());
 208         bindings.push(AssociatedTypeBinding {
 209             name: name![Output],
 210             type_ref: Some(type_ref),
 211             bounds: Vec::new(),
 212         });
 213     }
 214     if args.is_empty() && bindings.is_empty() {
 215         None
 216     } else {
 217         Some(GenericArgs { args, has_self_type: false, bindings })
 218     }
 219 }