544     }

   544     }

   545 

   545 

   546     /// Returns a mutable reference to the node at `path` if it exists

   546     /// Returns a mutable reference to the node at `path` if it exists

   547     ///

   547     ///

   548     /// This takes `root` instead of `&mut self` so that callers can mutate

   548     /// This takes `root` instead of `&mut self` so that callers can mutate

   550     fn get_node_mut<'tree>(

   554     fn get_node_mut<'tree>(

   551         on_disk: &'on_disk [u8],

   555         on_disk: &'on_disk [u8],

   552         unreachable_bytes: &mut u32,

   556         unreachable_bytes: &mut u32,

   553         root: &'tree mut ChildNodes<'on_disk>,

   557         root: &'tree mut ChildNodes<'on_disk>,

   554         path: &HgPath,

   558         path: &HgPath,

   555     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {

   560     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {

   556         let mut children = root;

   561         let mut children = root;

   557         let mut components = path.components();

   562         let mut components = path.components();

   558         let mut component =

   563         let mut component =

   559             components.next().expect("expected at least one components");

   564             components.next().expect("expected at least one components");

   561             if let Some(child) = children

   566             if let Some(child) = children

   562                 .make_mut(on_disk, unreachable_bytes)?

   567                 .make_mut(on_disk, unreachable_bytes)?

   563                 .get_mut(component)

   568                 .get_mut(component)

   564             {

   569             {

   565                 if let Some(next_component) = components.next() {

   570                 if let Some(next_component) = components.next() {

   566                     component = next_component;

   572                     component = next_component;

   567                     children = &mut child.children;

   573                     children = &mut child.children;

   568                 } else {

   574                 } else {

   569                     return Ok(Some(child));

   575                     return Ok(Some(child));

   570                 }

   576                 }

   784         let node = match DirstateMap::get_node_mut(

   790         let node = match DirstateMap::get_node_mut(

   785             self.on_disk,

   791             self.on_disk,

   786             &mut self.unreachable_bytes,

   792             &mut self.unreachable_bytes,

   787             &mut self.root,

   793             &mut self.root,

   788             path,

   794             path,

   789         )? {

   796         )? {

   790             Some(node) => node,

   797             Some(node) => node,

   791             None => return Ok(()),

   798             None => return Ok(()),

   792         };

   799         };

   793         if let NodeData::CachedDirectory { .. } = &node.data {

   800         if let NodeData::CachedDirectory { .. } = &node.data {

   805         let node = match DirstateMap::get_node_mut(

   812         let node = match DirstateMap::get_node_mut(

   806             self.on_disk,

   813             self.on_disk,

   807             &mut self.unreachable_bytes,

   814             &mut self.unreachable_bytes,

   808             &mut self.root,

   815             &mut self.root,

   809             path,

   816             path,

   810         )? {

   818         )? {

   811             Some(node) => node,

   819             Some(node) => node,

   812             None => return Ok(()),

   820             None => return Ok(()),

   813         };

   821         };

   814         match &node.data {

   822         match &node.data {

  1292             Ok(DirstateMap::get_node_mut(

  1300             Ok(DirstateMap::get_node_mut(

  1293                 map.on_disk,

  1301                 map.on_disk,

  1294                 unreachable_bytes,

  1302                 unreachable_bytes,

  1295                 &mut map.root,

  1303                 &mut map.root,

  1296                 key,

  1304                 key,

  1297             )?

  1306             )?

  1298             .and_then(|node| {

  1307             .and_then(|node| {

  1299                 if let Some(source) = &node.copy_source {

  1308                 if let Some(source) = &node.copy_source {

  1300                     *count -= 1;

  1309                     *count -= 1;

  1301                     DirstateMap::count_dropped_path(unreachable_bytes, source);

  1310                     DirstateMap::count_dropped_path(unreachable_bytes, source);