mirror of
https://github.com/nushell/nushell
synced 2024-12-28 22:13:10 +00:00
b2d0d9cf13
# Description In the PR #13832 I used some newtypes for the old IDs. `SpanId` and `RegId` already used newtypes, to streamline the code, I made them into the same style as the other marker-based IDs. Since `RegId` should be a bit smaller (it uses a `u32` instead of `usize`) according to @devyn, I made the `Id` type generic with `usize` as the default inner value. The question still stands how `Display` should be implemented if even. # User-Facing Changes Users of the internal values of `RegId` or `SpanId` have breaking changes but who outside nushell itself even uses these? # After Submitting The IDs will be streamlined and all type-safe.
119 lines
3.1 KiB
Rust
119 lines
3.1 KiB
Rust
use std::any;
|
|
use std::fmt::{Debug, Display, Error, Formatter};
|
|
use std::marker::PhantomData;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Id<M, V = usize> {
|
|
inner: V,
|
|
_phantom: PhantomData<M>,
|
|
}
|
|
|
|
impl<M, V> Id<M, V> {
|
|
/// Creates a new `Id`.
|
|
///
|
|
/// Using a distinct type like `Id` instead of `usize` helps us avoid mixing plain integers
|
|
/// with identifiers.
|
|
#[inline]
|
|
pub const fn new(inner: V) -> Self {
|
|
Self {
|
|
inner,
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<M, V> Id<M, V>
|
|
where
|
|
V: Copy,
|
|
{
|
|
/// Returns the inner value.
|
|
///
|
|
/// This requires an explicit call, ensuring we only use the raw value when intended.
|
|
#[inline]
|
|
pub const fn get(self) -> V {
|
|
self.inner
|
|
}
|
|
}
|
|
|
|
impl<M, V> Debug for Id<M, V>
|
|
where
|
|
V: Display,
|
|
{
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
|
|
let marker = any::type_name::<M>().split("::").last().expect("not empty");
|
|
write!(f, "{marker}Id({})", self.inner)
|
|
}
|
|
}
|
|
|
|
impl<M, V> Serialize for Id<M, V>
|
|
where
|
|
V: Serialize,
|
|
{
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
self.inner.serialize(serializer)
|
|
}
|
|
}
|
|
|
|
impl<'de, M, V> Deserialize<'de> for Id<M, V>
|
|
where
|
|
V: Deserialize<'de>,
|
|
{
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let inner = V::deserialize(deserializer)?;
|
|
Ok(Self {
|
|
inner,
|
|
_phantom: PhantomData,
|
|
})
|
|
}
|
|
}
|
|
|
|
pub mod marker {
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Var;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Decl;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Block;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Module;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Overlay;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct File;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct VirtualPath;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Span;
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct Reg;
|
|
}
|
|
|
|
pub type VarId = Id<marker::Var>;
|
|
pub type DeclId = Id<marker::Decl>;
|
|
pub type BlockId = Id<marker::Block>;
|
|
pub type ModuleId = Id<marker::Module>;
|
|
pub type OverlayId = Id<marker::Overlay>;
|
|
pub type FileId = Id<marker::File>;
|
|
pub type VirtualPathId = Id<marker::VirtualPath>;
|
|
pub type SpanId = Id<marker::Span>;
|
|
|
|
/// An ID for an [IR](crate::ir) register.
|
|
///
|
|
/// `%n` is a common shorthand for `RegId(n)`.
|
|
///
|
|
/// Note: `%0` is allocated with the block input at the beginning of a compiled block.
|
|
pub type RegId = Id<marker::Reg, u32>;
|
|
|
|
impl Display for RegId {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "%{}", self.get())
|
|
}
|
|
}
|