This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7301

rust: introduce SIZE_FROM_OTHER_PARENT constant
ClosedPublic

Authored by Alphare on Nov 7 2019, 5:18 AM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHG8210c3f46912: rust: introduce SIZE_FROM_OTHER_PARENT constant
Summary

This will clarify what -2 meant in the codebase.
This change also merged imports in affected files for cleanup.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare created this revision.Nov 7 2019, 5:18 AM
kevincox accepted this revision.Nov 7 2019, 1:24 PM
Alphare updated this revision to Diff 17742.Nov 8 2019, 7:51 AM
Alphare added a commit: rHG8210c3f46912: rust: introduce SIZE_FROM_OTHER_PARENT constant.Nov 11 2019, 4:08 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG8210c3f46912: rust: introduce SIZE_FROM_OTHER_PARENT constant (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 18020

rust/hg-core/src/dirstate.rs

#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
pub state: EntryState, pub state: EntryState,
pub mode: i32, pub mode: i32,
pub mtime: i32, pub mtime: i32,
pub size: i32, pub size: i32,
} }
/// A `DirstateEntry` with a size of `-2` means that it was merged from the
/// other parent. This allows revert to pick the right status back during a
/// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
pub type StateMap = HashMap<HgPathBuf, DirstateEntry>; pub type StateMap = HashMap<HgPathBuf, DirstateEntry>;
pub type StateMapIter<'a> = hash_map::Iter<'a, HgPathBuf, DirstateEntry>; pub type StateMapIter<'a> = hash_map::Iter<'a, HgPathBuf, DirstateEntry>;
pub type CopyMap = HashMap<HgPathBuf, HgPathBuf>; pub type CopyMap = HashMap<HgPathBuf, HgPathBuf>;
pub type CopyMapIter<'a> = hash_map::Iter<'a, HgPathBuf, HgPathBuf>; pub type CopyMapIter<'a> = hash_map::Iter<'a, HgPathBuf, HgPathBuf>;
#[derive(Copy, Clone, Debug, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum EntryState { pub enum EntryState {
Normal, Normal,

rust/hg-core/src/dirstate/dirstate_map.rs

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::{ use crate::{
dirstate::{parsers::PARENT_SIZE, EntryState}, dirstate::{parsers::PARENT_SIZE, EntryState, SIZE_FROM_OTHER_PARENT},
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::files::normalize_case, utils::{
files::normalize_case,
hg_path::{HgPath, HgPathBuf},
},
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateMapError,
DirstateParents, DirstateParseError, StateMap, DirstateParents, DirstateParseError, StateMap,
}; };
use core::borrow::Borrow; use core::borrow::Borrow;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::convert::TryInto; use std::convert::TryInto;
use std::iter::FromIterator; use std::iter::FromIterator;
use std::ops::Deref; use std::ops::Deref;
use std::time::Duration; use std::time::Duration;
pub type FileFoldMap = HashMap<HgPathBuf, HgPathBuf>; pub type FileFoldMap = HashMap<HgPathBuf, HgPathBuf>;
const NULL_ID: [u8; 20] = [0; 20]; const NULL_ID: [u8; 20] = [0; 20];
const MTIME_UNSET: i32 = -1; const MTIME_UNSET: i32 = -1;
const SIZE_DIRTY: i32 = -2;
#[derive(Default)] #[derive(Default)]
pub struct DirstateMap { pub struct DirstateMap {
state_map: StateMap, state_map: StateMap,
pub copy_map: CopyMap, pub copy_map: CopyMap,
file_fold_map: Option<FileFoldMap>, file_fold_map: Option<FileFoldMap>,
pub dirs: Option<DirsMultiset>, pub dirs: Option<DirsMultiset>,
pub all_dirs: Option<DirsMultiset>, pub all_dirs: Option<DirsMultiset>,
} }
} }
self.state_map.insert(filename.to_owned(), entry.to_owned()); self.state_map.insert(filename.to_owned(), entry.to_owned());
if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET { if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET {
self.non_normal_set.insert(filename.to_owned()); self.non_normal_set.insert(filename.to_owned());
} }
if entry.size == SIZE_DIRTY { if entry.size == SIZE_FROM_OTHER_PARENT {
self.other_parent_set.insert(filename.to_owned()); self.other_parent_set.insert(filename.to_owned());
} }
} }
/// Mark a file as removed in the dirstate. /// Mark a file as removed in the dirstate.
/// ///
/// The `size` parameter is used to store sentinel values that indicate /// The `size` parameter is used to store sentinel values that indicate
/// the file's previous state. In the future, we should refactor this /// the file's previous state. In the future, we should refactor this
DirstateEntry { DirstateEntry {
state, size, mtime, .. state, size, mtime, ..
}, },
) in self.state_map.iter() ) in self.state_map.iter()
{ {
if *state != EntryState::Normal || *mtime == MTIME_UNSET { if *state != EntryState::Normal || *mtime == MTIME_UNSET {
non_normal.insert(filename.to_owned()); non_normal.insert(filename.to_owned());
} }
if *state == EntryState::Normal && *size == SIZE_DIRTY { if *state == EntryState::Normal && *size == SIZE_FROM_OTHER_PARENT
{
other_parent.insert(filename.to_owned()); other_parent.insert(filename.to_owned());
} }
} }
(non_normal, other_parent) (non_normal, other_parent)
} }
/// Both of these setters and their uses appear to be the simplest way to /// Both of these setters and their uses appear to be the simplest way to

rust/hg-core/src/dirstate/status.rs

// status.rs // status.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Rust implementation of dirstate.status (dirstate.py). //! Rust implementation of dirstate.status (dirstate.py).
//! It is currently missing a lot of functionality compared to the Python one //! It is currently missing a lot of functionality compared to the Python one
//! and will only be triggered in narrow cases. //! and will only be triggered in narrow cases.
use crate::utils::files::HgMetadata; use crate::{
use crate::utils::hg_path::{hg_path_to_path_buf, HgPath}; dirstate::SIZE_FROM_OTHER_PARENT,
use crate::{CopyMap, DirstateEntry, DirstateMap, EntryState}; utils::{
files::HgMetadata,
hg_path::{hg_path_to_path_buf, HgPath},
},
CopyMap, DirstateEntry, DirstateMap, EntryState,
};
use rayon::prelude::*; use rayon::prelude::*;
use std::path::Path; use std::path::Path;
/// Marker enum used to dispatch new status entries into the right collections. /// Marker enum used to dispatch new status entries into the right collections.
/// Is similar to `crate::EntryState`, but represents the transient state of /// Is similar to `crate::EntryState`, but represents the transient state of
/// entries during the lifetime of a command. /// entries during the lifetime of a command.
enum Dispatch { enum Dispatch {
Unsure, Unsure,
} = metadata; } = metadata;
match state { match state {
EntryState::Normal => { EntryState::Normal => {
let size_changed = mod_compare(size, st_size as i32); let size_changed = mod_compare(size, st_size as i32);
let mode_changed = let mode_changed =
(mode ^ st_mode as i32) & 0o100 != 0o000 && check_exec; (mode ^ st_mode as i32) & 0o100 != 0o000 && check_exec;
let metadata_changed = size >= 0 && (size_changed || mode_changed); let metadata_changed = size >= 0 && (size_changed || mode_changed);
let other_parent = size == -2; let other_parent = size == SIZE_FROM_OTHER_PARENT;
if metadata_changed if metadata_changed
|| other_parent || other_parent
|| copy_map.contains_key(filename.as_ref()) || copy_map.contains_key(filename.as_ref())
{ {
Dispatch::Modified Dispatch::Modified
} else if mod_compare(mtime, st_mtime as i32) { } else if mod_compare(mtime, st_mtime as i32) {
Dispatch::Unsure Dispatch::Unsure
} else if st_mtime == last_normal_time { } else if st_mtime == last_normal_time {