]> git.lizzy.rs Git - rust.git/commitdiff
Merge #6896
authorbors[bot] <26634292+bors[bot]@users.noreply.github.com>
Wed, 16 Dec 2020 17:08:03 +0000 (17:08 +0000)
committerGitHub <noreply@github.com>
Wed, 16 Dec 2020 17:08:03 +0000 (17:08 +0000)
6896: Node-ify lifetimes r=jonas-schievink a=Veykril

Let's see if this passes the tests ðŸ¤ž

Depends on https://github.com/rust-analyzer/ungrammar/pull/15

Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>
Co-authored-by: Jonas Schievink <jonas.schievink@ferrous-systems.com>
Co-authored-by: Lukas Wirth <lukastw97@gmail.com>
1  2 
crates/hir_def/src/generics.rs

index 924046435b8a7e72c005241f3aad0aa6a270311b,bc0125f0b13669991abb9eb9678f77f4f04abab9..41134d23b3d928cc7d8ca5779441c69329a7d5bf
@@@ -19,7 -19,7 +19,7 @@@ use crate::
      db::DefDatabase,
      dyn_map::DynMap,
      keys,
 -    src::HasSource,
 +    src::{HasChildSource, HasSource},
      type_ref::{LifetimeRef, TypeBound, TypeRef},
      AdtId, GenericDefId, LifetimeParamId, LocalLifetimeParamId, LocalTypeParamId, Lookup,
      TypeParamId,
@@@ -73,9 -73,9 +73,9 @@@ pub enum WherePredicateTypeTarget 
  }
  
  #[derive(Default)]
 -pub struct SourceMaps {
 -    pub type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
 -    pub lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
 +pub(crate) struct SourceMap {
 +    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
 +    lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
  }
  
  impl GenericParams {
          Arc::new(generics)
      }
  
 -    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMaps>) {
 +    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
          let mut generics = GenericParams::default();
 -        let mut sm = SourceMaps::default();
 +        let mut sm = SourceMap::default();
  
          // FIXME: add `: Sized` bound for everything except for `Self` in traits
          let file_id = match def {
      pub(crate) fn fill(
          &mut self,
          lower_ctx: &LowerCtx,
 -        sm: &mut SourceMaps,
 +        sm: &mut SourceMap,
          node: &dyn GenericParamsOwner,
      ) {
          if let Some(params) = node.generic_param_list() {
      fn fill_params(
          &mut self,
          lower_ctx: &LowerCtx,
 -        sm: &mut SourceMaps,
 +        sm: &mut SourceMap,
          params: ast::GenericParamList,
      ) {
          for type_param in params.type_params() {
              self.fill_bounds(&lower_ctx, &type_param, Either::Left(type_ref));
          }
          for lifetime_param in params.lifetime_params() {
-             let name = lifetime_param
-                 .lifetime_token()
-                 .map_or_else(Name::missing, |tok| Name::new_lifetime(&tok));
+             let name =
+                 lifetime_param.lifetime().map_or_else(Name::missing, |lt| Name::new_lifetime(&lt));
              let param = LifetimeParamData { name: name.clone() };
              let param_id = self.lifetimes.alloc(param);
              sm.lifetime_params.insert(param_id, lifetime_param.clone());
          for pred in where_clause.predicates() {
              let target = if let Some(type_ref) = pred.ty() {
                  Either::Left(TypeRef::from_ast(lower_ctx, type_ref))
-             } else if let Some(lifetime_tok) = pred.lifetime_token() {
-                 Either::Right(LifetimeRef::from_token(lifetime_tok))
+             } else if let Some(lifetime) = pred.lifetime() {
+                 Either::Right(LifetimeRef::new(&lifetime))
              } else {
                  continue;
              };
          })
      }
  }
 -impl GenericDefId {
 -    // FIXME: Change HasChildSource's ChildId AssocItem to be a generic parameter instead
 -    pub fn child_source(&self, db: &dyn DefDatabase) -> InFile<SourceMaps> {
 -        GenericParams::new(db, *self).1
 +
 +impl HasChildSource<LocalTypeParamId> for GenericDefId {
 +    type Value = Either<ast::Trait, ast::TypeParam>;
 +    fn child_source(
 +        &self,
 +        db: &dyn DefDatabase,
 +    ) -> InFile<ArenaMap<LocalTypeParamId, Self::Value>> {
 +        GenericParams::new(db, *self).1.map(|source_maps| source_maps.type_params)
 +    }
 +}
 +
 +impl HasChildSource<LocalLifetimeParamId> for GenericDefId {
 +    type Value = ast::LifetimeParam;
 +    fn child_source(
 +        &self,
 +        db: &dyn DefDatabase,
 +    ) -> InFile<ArenaMap<LocalLifetimeParamId, Self::Value>> {
 +        GenericParams::new(db, *self).1.map(|source_maps| source_maps.lifetime_params)
      }
  }