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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 17742

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 {