crates/hir_def/src/lib.rs

   1 //! `hir_def` crate contains everything between macro expansion and type
   2 //! inference.
   3 //!
   4 //! It defines various items (structs, enums, traits) which comprises Rust code,
   5 //! as well as an algorithm for resolving paths to such entities.
   6 //!
   7 //! Note that `hir_def` is a work in progress, so not all of the above is
   8 //! actually true.
   9
  10 #[allow(unused)]
  11 macro_rules! eprintln {
  12     ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
  13 }
  14
  15 pub mod db;
  16
  17 pub mod attr;
  18 pub mod path;
  19 pub mod type_ref;
  20 pub mod builtin_type;
  21 pub mod builtin_attr;
  22 pub mod diagnostics;
  23 pub mod per_ns;
  24 pub mod item_scope;
  25
  26 pub mod dyn_map;
  27 pub mod keys;
  28
  29 pub mod item_tree;
  30
  31 pub mod adt;
  32 pub mod data;
  33 pub mod generics;
  34 pub mod lang_item;
  35
  36 pub mod expr;
  37 pub mod body;
  38 pub mod resolver;
  39
  40 mod trace;
  41 pub mod nameres;
  42
  43 pub mod src;
  44 pub mod child_by_source;
  45
  46 pub mod visibility;
  47 pub mod find_path;
  48 pub mod import_map;
  49
  50 #[cfg(test)]
  51 mod test_db;
  52
  53 use std::hash::{Hash, Hasher};
  54
  55 use arena::Idx;
  56 use base_db::{impl_intern_key, salsa, CrateId};
  57 use hir_expand::{
  58     ast_id_map::FileAstId, eager::expand_eager_macro, hygiene::Hygiene, AstId, HirFileId, InFile,
  59     MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
  60 };
  61 use syntax::ast;
  62
  63 use crate::builtin_type::BuiltinType;
  64 use item_tree::{
  65     Const, Enum, Function, Impl, ItemTreeId, ItemTreeNode, ModItem, Static, Struct, Trait,
  66     TypeAlias, Union,
  67 };
  68 use stdx::impl_from;
  69
  70 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  71 pub struct ModuleId {
  72     pub krate: CrateId,
  73     pub local_id: LocalModuleId,
  74 }
  75
  76 /// An ID of a module, **local** to a specific crate
  77 pub type LocalModuleId = Idx<nameres::ModuleData>;
  78
  79 #[derive(Debug)]
  80 pub struct ItemLoc<N: ItemTreeNode> {
  81     pub container: ContainerId,
  82     pub id: ItemTreeId<N>,
  83 }
  84
  85 impl<N: ItemTreeNode> Clone for ItemLoc<N> {
  86     fn clone(&self) -> Self {
  87         Self { container: self.container, id: self.id }
  88     }
  89 }
  90
  91 impl<N: ItemTreeNode> Copy for ItemLoc<N> {}
  92
  93 impl<N: ItemTreeNode> PartialEq for ItemLoc<N> {
  94     fn eq(&self, other: &Self) -> bool {
  95         self.container == other.container && self.id == other.id
  96     }
  97 }
  98
  99 impl<N: ItemTreeNode> Eq for ItemLoc<N> {}
 100
 101 impl<N: ItemTreeNode> Hash for ItemLoc<N> {
 102     fn hash<H: Hasher>(&self, state: &mut H) {
 103         self.container.hash(state);
 104         self.id.hash(state);
 105     }
 106 }
 107
 108 #[derive(Debug)]
 109 pub struct AssocItemLoc<N: ItemTreeNode> {
 110     pub container: AssocContainerId,
 111     pub id: ItemTreeId<N>,
 112 }
 113
 114 impl<N: ItemTreeNode> Clone for AssocItemLoc<N> {
 115     fn clone(&self) -> Self {
 116         Self { container: self.container, id: self.id }
 117     }
 118 }
 119
 120 impl<N: ItemTreeNode> Copy for AssocItemLoc<N> {}
 121
 122 impl<N: ItemTreeNode> PartialEq for AssocItemLoc<N> {
 123     fn eq(&self, other: &Self) -> bool {
 124         self.container == other.container && self.id == other.id
 125     }
 126 }
 127
 128 impl<N: ItemTreeNode> Eq for AssocItemLoc<N> {}
 129
 130 impl<N: ItemTreeNode> Hash for AssocItemLoc<N> {
 131     fn hash<H: Hasher>(&self, state: &mut H) {
 132         self.container.hash(state);
 133         self.id.hash(state);
 134     }
 135 }
 136
 137 macro_rules! impl_intern {
 138     ($id:ident, $loc:ident, $intern:ident, $lookup:ident) => {
 139         impl_intern_key!($id);
 140
 141         impl Intern for $loc {
 142             type ID = $id;
 143             fn intern(self, db: &dyn db::DefDatabase) -> $id {
 144                 db.$intern(self)
 145             }
 146         }
 147
 148         impl Lookup for $id {
 149             type Data = $loc;
 150             fn lookup(&self, db: &dyn db::DefDatabase) -> $loc {
 151                 db.$lookup(*self)
 152             }
 153         }
 154     };
 155 }
 156
 157 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 158 pub struct FunctionId(salsa::InternId);
 159 type FunctionLoc = AssocItemLoc<Function>;
 160 impl_intern!(FunctionId, FunctionLoc, intern_function, lookup_intern_function);
 161
 162 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 163 pub struct StructId(salsa::InternId);
 164 type StructLoc = ItemLoc<Struct>;
 165 impl_intern!(StructId, StructLoc, intern_struct, lookup_intern_struct);
 166
 167 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 168 pub struct UnionId(salsa::InternId);
 169 pub type UnionLoc = ItemLoc<Union>;
 170 impl_intern!(UnionId, UnionLoc, intern_union, lookup_intern_union);
 171
 172 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 173 pub struct EnumId(salsa::InternId);
 174 pub type EnumLoc = ItemLoc<Enum>;
 175 impl_intern!(EnumId, EnumLoc, intern_enum, lookup_intern_enum);
 176
 177 // FIXME: rename to `VariantId`, only enums can ave variants
 178 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 179 pub struct EnumVariantId {
 180     pub parent: EnumId,
 181     pub local_id: LocalEnumVariantId,
 182 }
 183
 184 pub type LocalEnumVariantId = Idx<adt::EnumVariantData>;
 185
 186 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 187 pub struct FieldId {
 188     pub parent: VariantId,
 189     pub local_id: LocalFieldId,
 190 }
 191
 192 pub type LocalFieldId = Idx<adt::FieldData>;
 193
 194 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 195 pub struct ConstId(salsa::InternId);
 196 type ConstLoc = AssocItemLoc<Const>;
 197 impl_intern!(ConstId, ConstLoc, intern_const, lookup_intern_const);
 198
 199 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 200 pub struct StaticId(salsa::InternId);
 201 pub type StaticLoc = ItemLoc<Static>;
 202 impl_intern!(StaticId, StaticLoc, intern_static, lookup_intern_static);
 203
 204 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 205 pub struct TraitId(salsa::InternId);
 206 pub type TraitLoc = ItemLoc<Trait>;
 207 impl_intern!(TraitId, TraitLoc, intern_trait, lookup_intern_trait);
 208
 209 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 210 pub struct TypeAliasId(salsa::InternId);
 211 type TypeAliasLoc = AssocItemLoc<TypeAlias>;
 212 impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
 213
 214 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 215 pub struct ImplId(salsa::InternId);
 216 type ImplLoc = ItemLoc<Impl>;
 217 impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
 218
 219 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 220 pub struct TypeParamId {
 221     pub parent: GenericDefId,
 222     pub local_id: LocalTypeParamId,
 223 }
 224
 225 pub type LocalTypeParamId = Idx<generics::TypeParamData>;
 226
 227 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 228 pub struct LifetimeParamId {
 229     pub parent: GenericDefId,
 230     pub local_id: LocalLifetimeParamId,
 231 }
 232 pub type LocalLifetimeParamId = Idx<generics::LifetimeParamData>;
 233
 234 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 235 pub struct ConstParamId {
 236     pub parent: GenericDefId,
 237     pub local_id: LocalConstParamId,
 238 }
 239 pub type LocalConstParamId = Idx<generics::ConstParamData>;
 240
 241 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 242 pub enum ContainerId {
 243     ModuleId(ModuleId),
 244     DefWithBodyId(DefWithBodyId),
 245 }
 246
 247 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 248 pub enum AssocContainerId {
 249     ContainerId(ContainerId),
 250     ImplId(ImplId),
 251     TraitId(TraitId),
 252 }
 253 impl_from!(ContainerId for AssocContainerId);
 254
 255 /// A Data Type
 256 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 257 pub enum AdtId {
 258     StructId(StructId),
 259     UnionId(UnionId),
 260     EnumId(EnumId),
 261 }
 262 impl_from!(StructId, UnionId, EnumId for AdtId);
 263
 264 /// The defs which can be visible in the module.
 265 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 266 pub enum ModuleDefId {
 267     ModuleId(ModuleId),
 268     FunctionId(FunctionId),
 269     AdtId(AdtId),
 270     // Can't be directly declared, but can be imported.
 271     EnumVariantId(EnumVariantId),
 272     ConstId(ConstId),
 273     StaticId(StaticId),
 274     TraitId(TraitId),
 275     TypeAliasId(TypeAliasId),
 276     BuiltinType(BuiltinType),
 277 }
 278 impl_from!(
 279     ModuleId,
 280     FunctionId,
 281     AdtId(StructId, EnumId, UnionId),
 282     EnumVariantId,
 283     ConstId,
 284     StaticId,
 285     TraitId,
 286     TypeAliasId,
 287     BuiltinType
 288     for ModuleDefId
 289 );
 290
 291 /// The defs which have a body.
 292 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 293 pub enum DefWithBodyId {
 294     FunctionId(FunctionId),
 295     StaticId(StaticId),
 296     ConstId(ConstId),
 297 }
 298
 299 impl_from!(FunctionId, ConstId, StaticId for DefWithBodyId);
 300
 301 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 302 pub enum AssocItemId {
 303     FunctionId(FunctionId),
 304     ConstId(ConstId),
 305     TypeAliasId(TypeAliasId),
 306 }
 307 // FIXME: not every function, ... is actually an assoc item. maybe we should make
 308 // sure that you can only turn actual assoc items into AssocItemIds. This would
 309 // require not implementing From, and instead having some checked way of
 310 // casting them, and somehow making the constructors private, which would be annoying.
 311 impl_from!(FunctionId, ConstId, TypeAliasId for AssocItemId);
 312
 313 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 314 pub enum GenericDefId {
 315     FunctionId(FunctionId),
 316     AdtId(AdtId),
 317     TraitId(TraitId),
 318     TypeAliasId(TypeAliasId),
 319     ImplId(ImplId),
 320     // enum variants cannot have generics themselves, but their parent enums
 321     // can, and this makes some code easier to write
 322     EnumVariantId(EnumVariantId),
 323     // consts can have type parameters from their parents (i.e. associated consts of traits)
 324     ConstId(ConstId),
 325 }
 326 impl_from!(
 327     FunctionId,
 328     AdtId(StructId, EnumId, UnionId),
 329     TraitId,
 330     TypeAliasId,
 331     ImplId,
 332     EnumVariantId,
 333     ConstId
 334     for GenericDefId
 335 );
 336
 337 impl From<AssocItemId> for GenericDefId {
 338     fn from(item: AssocItemId) -> Self {
 339         match item {
 340             AssocItemId::FunctionId(f) => f.into(),
 341             AssocItemId::ConstId(c) => c.into(),
 342             AssocItemId::TypeAliasId(t) => t.into(),
 343         }
 344     }
 345 }
 346
 347 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 348 pub enum AttrDefId {
 349     ModuleId(ModuleId),
 350     FieldId(FieldId),
 351     AdtId(AdtId),
 352     FunctionId(FunctionId),
 353     EnumVariantId(EnumVariantId),
 354     StaticId(StaticId),
 355     ConstId(ConstId),
 356     TraitId(TraitId),
 357     TypeAliasId(TypeAliasId),
 358     MacroDefId(MacroDefId),
 359     ImplId(ImplId),
 360 }
 361
 362 impl_from!(
 363     ModuleId,
 364     FieldId,
 365     AdtId(StructId, EnumId, UnionId),
 366     EnumVariantId,
 367     StaticId,
 368     ConstId,
 369     FunctionId,
 370     TraitId,
 371     TypeAliasId,
 372     MacroDefId,
 373     ImplId
 374     for AttrDefId
 375 );
 376
 377 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 378 pub enum VariantId {
 379     EnumVariantId(EnumVariantId),
 380     StructId(StructId),
 381     UnionId(UnionId),
 382 }
 383 impl_from!(EnumVariantId, StructId, UnionId for VariantId);
 384
 385 trait Intern {
 386     type ID;
 387     fn intern(self, db: &dyn db::DefDatabase) -> Self::ID;
 388 }
 389
 390 pub trait Lookup {
 391     type Data;
 392     fn lookup(&self, db: &dyn db::DefDatabase) -> Self::Data;
 393 }
 394
 395 pub trait HasModule {
 396     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId;
 397 }
 398
 399 impl HasModule for ContainerId {
 400     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 401         match *self {
 402             ContainerId::ModuleId(it) => it,
 403             ContainerId::DefWithBodyId(it) => it.module(db),
 404         }
 405     }
 406 }
 407
 408 impl HasModule for AssocContainerId {
 409     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 410         match *self {
 411             AssocContainerId::ContainerId(it) => it.module(db),
 412             AssocContainerId::ImplId(it) => it.lookup(db).container.module(db),
 413             AssocContainerId::TraitId(it) => it.lookup(db).container.module(db),
 414         }
 415     }
 416 }
 417
 418 impl<N: ItemTreeNode> HasModule for AssocItemLoc<N> {
 419     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 420         self.container.module(db)
 421     }
 422 }
 423
 424 impl HasModule for AdtId {
 425     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 426         match self {
 427             AdtId::StructId(it) => it.lookup(db).container,
 428             AdtId::UnionId(it) => it.lookup(db).container,
 429             AdtId::EnumId(it) => it.lookup(db).container,
 430         }
 431         .module(db)
 432     }
 433 }
 434
 435 impl HasModule for VariantId {
 436     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 437         match self {
 438             VariantId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
 439             VariantId::StructId(it) => it.lookup(db).container.module(db),
 440             VariantId::UnionId(it) => it.lookup(db).container.module(db),
 441         }
 442     }
 443 }
 444
 445 impl HasModule for DefWithBodyId {
 446     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 447         match self {
 448             DefWithBodyId::FunctionId(it) => it.lookup(db).module(db),
 449             DefWithBodyId::StaticId(it) => it.lookup(db).module(db),
 450             DefWithBodyId::ConstId(it) => it.lookup(db).module(db),
 451         }
 452     }
 453 }
 454
 455 impl DefWithBodyId {
 456     pub fn as_mod_item(self, db: &dyn db::DefDatabase) -> ModItem {
 457         match self {
 458             DefWithBodyId::FunctionId(it) => it.lookup(db).id.value.into(),
 459             DefWithBodyId::StaticId(it) => it.lookup(db).id.value.into(),
 460             DefWithBodyId::ConstId(it) => it.lookup(db).id.value.into(),
 461         }
 462     }
 463 }
 464
 465 impl HasModule for GenericDefId {
 466     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 467         match self {
 468             GenericDefId::FunctionId(it) => it.lookup(db).module(db),
 469             GenericDefId::AdtId(it) => it.module(db),
 470             GenericDefId::TraitId(it) => it.lookup(db).container.module(db),
 471             GenericDefId::TypeAliasId(it) => it.lookup(db).module(db),
 472             GenericDefId::ImplId(it) => it.lookup(db).container.module(db),
 473             GenericDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db),
 474             GenericDefId::ConstId(it) => it.lookup(db).module(db),
 475         }
 476     }
 477 }
 478
 479 impl HasModule for StaticLoc {
 480     fn module(&self, db: &dyn db::DefDatabase) -> ModuleId {
 481         self.container.module(db)
 482     }
 483 }
 484
 485 impl AttrDefId {
 486     pub fn krate(&self, db: &dyn db::DefDatabase) -> CrateId {
 487         match self {
 488             AttrDefId::ModuleId(it) => it.krate,
 489             AttrDefId::FieldId(it) => it.parent.module(db).krate,
 490             AttrDefId::AdtId(it) => it.module(db).krate,
 491             AttrDefId::FunctionId(it) => it.lookup(db).module(db).krate,
 492             AttrDefId::EnumVariantId(it) => it.parent.lookup(db).container.module(db).krate,
 493             AttrDefId::StaticId(it) => it.lookup(db).module(db).krate,
 494             AttrDefId::ConstId(it) => it.lookup(db).module(db).krate,
 495             AttrDefId::TraitId(it) => it.lookup(db).container.module(db).krate,
 496             AttrDefId::TypeAliasId(it) => it.lookup(db).module(db).krate,
 497             AttrDefId::ImplId(it) => it.lookup(db).container.module(db).krate,
 498             // FIXME: `MacroDefId` should store the defining module, then this can implement
 499             // `HasModule`
 500             AttrDefId::MacroDefId(it) => it.krate,
 501         }
 502     }
 503 }
 504
 505 /// A helper trait for converting to MacroCallId
 506 pub trait AsMacroCall {
 507     fn as_call_id(
 508         &self,
 509         db: &dyn db::DefDatabase,
 510         krate: CrateId,
 511         resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
 512     ) -> Option<MacroCallId> {
 513         self.as_call_id_with_errors(db, krate, resolver, &mut |_| ())
 514     }
 515
 516     fn as_call_id_with_errors(
 517         &self,
 518         db: &dyn db::DefDatabase,
 519         krate: CrateId,
 520         resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
 521         error_sink: &mut dyn FnMut(mbe::ExpandError),
 522     ) -> Option<MacroCallId>;
 523 }
 524
 525 impl AsMacroCall for InFile<&ast::MacroCall> {
 526     fn as_call_id_with_errors(
 527         &self,
 528         db: &dyn db::DefDatabase,
 529         krate: CrateId,
 530         resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
 531         error_sink: &mut dyn FnMut(mbe::ExpandError),
 532     ) -> Option<MacroCallId> {
 533         let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));
 534         let h = Hygiene::new(db.upcast(), self.file_id);
 535         let path = self.value.path().and_then(|path| path::ModPath::from_src(path, &h));
 536
 537         if path.is_none() {
 538             error_sink(mbe::ExpandError::Other("malformed macro invocation".into()));
 539         }
 540
 541         AstIdWithPath::new(ast_id.file_id, ast_id.value, path?)
 542             .as_call_id_with_errors(db, krate, resolver, error_sink)
 543     }
 544 }
 545
 546 /// Helper wrapper for `AstId` with `ModPath`
 547 #[derive(Clone, Debug, Eq, PartialEq)]
 548 struct AstIdWithPath<T: ast::AstNode> {
 549     ast_id: AstId<T>,
 550     path: path::ModPath,
 551 }
 552
 553 impl<T: ast::AstNode> AstIdWithPath<T> {
 554     fn new(file_id: HirFileId, ast_id: FileAstId<T>, path: path::ModPath) -> AstIdWithPath<T> {
 555         AstIdWithPath { ast_id: AstId::new(file_id, ast_id), path }
 556     }
 557 }
 558
 559 impl AsMacroCall for AstIdWithPath<ast::MacroCall> {
 560     fn as_call_id_with_errors(
 561         &self,
 562         db: &dyn db::DefDatabase,
 563         krate: CrateId,
 564         resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
 565         error_sink: &mut dyn FnMut(mbe::ExpandError),
 566     ) -> Option<MacroCallId> {
 567         let def: MacroDefId = resolver(self.path.clone()).or_else(|| {
 568             error_sink(mbe::ExpandError::Other(format!("could not resolve macro `{}`", self.path)));
 569             None
 570         })?;
 571
 572         if let MacroDefKind::BuiltInEager(_) = def.kind {
 573             let macro_call = InFile::new(self.ast_id.file_id, self.ast_id.to_node(db.upcast()));
 574             let hygiene = Hygiene::new(db.upcast(), self.ast_id.file_id);
 575
 576             Some(
 577                 expand_eager_macro(
 578                     db.upcast(),
 579                     krate,
 580                     macro_call,
 581                     def,
 582                     &|path: ast::Path| resolver(path::ModPath::from_src(path, &hygiene)?),
 583                     error_sink,
 584                 )
 585                 .ok()?
 586                 .into(),
 587             )
 588         } else {
 589             Some(def.as_lazy_macro(db.upcast(), krate, MacroCallKind::FnLike(self.ast_id)).into())
 590         }
 591     }
 592 }
 593
 594 impl AsMacroCall for AstIdWithPath<ast::Item> {
 595     fn as_call_id_with_errors(
 596         &self,
 597         db: &dyn db::DefDatabase,
 598         krate: CrateId,
 599         resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
 600         error_sink: &mut dyn FnMut(mbe::ExpandError),
 601     ) -> Option<MacroCallId> {
 602         let def: MacroDefId = resolver(self.path.clone()).or_else(|| {
 603             error_sink(mbe::ExpandError::Other(format!("could not resolve macro `{}`", self.path)));
 604             None
 605         })?;
 606
 607         Some(
 608             def.as_lazy_macro(
 609                 db.upcast(),
 610                 krate,
 611                 MacroCallKind::Attr(self.ast_id, self.path.segments.last()?.to_string()),
 612             )
 613             .into(),
 614         )
 615     }
 616 }