use core::num::{NonZeroU32, NonZeroU64};
use nybl::parser::ParamMode;
#[cfg(all(feature = "no_std", not(feature = "std")))]
use alloc::{string::String, sync::Arc, vec::Vec};
#[cfg(any(feature = "std", not(feature = "no_std")))]
use std::sync::Arc;
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Instr {
LoadConst(ConstIdx),
LoadNone,
LoadTrue,
LoadFalse,
LoadVar(NameIdx),
DefineLocal(NameIdx),
StoreVar(NameIdx),
LoadLocal(SlotIdx),
StoreLocal(SlotIdx),
CompoundAssign {
target: AssignBack,
op: InPlaceAssignOp,
},
AddLocals(SlotIdx, SlotIdx),
LtLocals(SlotIdx, SlotIdx),
IncLocalInt(SlotIdx, i32),
LoadLocalAddInt(SlotIdx, i32),
LtLocalInt(SlotIdx, i32),
PushScope,
PopScope,
Pop,
Dup,
Dup2,
Add,
Sub,
Mul,
Div,
Rem,
Eq,
NotEq,
Lt,
Gt,
LtEq,
GtEq,
Neg,
Not,
TruthyToBool,
GetIndex,
SetIndex,
SetIndexInPlace {
target: AssignBack,
op: InPlaceAssignOp,
},
AssignPlace {
place: PlaceIdx,
op: InPlaceAssignOp,
},
StringInterp(InterpIdx),
MakeArray(u32),
MakeDict(u32),
Call {
name: NameIdx,
argc: u32,
},
CallValue {
argc: u32,
},
PrepareCall {
name: NameIdx,
site: CallSiteIdx,
},
PrepareCallValue {
site: CallSiteIdx,
},
PrepareMethodValue {
method: NameIdx,
site: CallSiteIdx,
nested_place: bool,
},
PrepareMethodNamed {
target: NamespaceRef,
method: NameIdx,
site: CallSiteIdx,
},
PrepareMethodPlace {
place: PlaceIdx,
method: NameIdx,
site: CallSiteIdx,
},
CallPrepared {
site: CallSiteIdx,
},
CallMethod {
method: NameIdx,
argc: u32,
assign_back_to: Option<AssignBack>,
nested_place: bool,
},
CallMethodInPlace {
target: NamespaceRef,
method: NameIdx,
argc: u32,
},
DefineFn(FnIdx),
MakeLambda(FnIdx),
Return,
ReturnNone,
MakeIter,
IterNext {
target: CodeOffset,
},
MakeRepeatCount,
RepeatNext {
target: CodeOffset,
},
PopLoopState(LoopStateKind),
Jump(CodeOffset),
JumpIfFalse(CodeOffset),
JumpIfFalsePeek(CodeOffset),
JumpIfTruePeek(CodeOffset),
Use(UseIdx),
DefineStruct(StructIdx),
DefineEnum(EnumIdx),
DefineMethod {
type_name: NameIdx,
method_name: NameIdx,
fn_idx: FnIdx,
},
ValidateStructConstruct {
namespace: Option<NamespaceIdx>,
type_name: NameIdx,
fields: ConstructFieldsIdx,
},
ValidateEnumConstruct {
namespace: Option<NamespaceIdx>,
type_name: NameIdx,
variant: NameIdx,
shape: EnumConstructShape,
fields: ConstructFieldsIdx,
},
ConstructStruct {
namespace: Option<NamespaceIdx>,
type_name: NameIdx,
count: u32,
},
ConstructEnum {
namespace: Option<NamespaceIdx>,
type_name: NameIdx,
variant: NameIdx,
shape: EnumConstructShape,
},
FieldGet(NameIdx),
FieldSet(NameIdx),
FieldSetInPlace {
target: AssignBack,
field: NameIdx,
op: InPlaceAssignOp,
},
MatchFail {
pattern: PatternIdx,
on_fail: CodeOffset,
},
MatchExhausted,
TryUnwrap,
Halt,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ConstIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NameIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct FnIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SlotIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct InterpIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CodeOffset(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LoopStateKind {
Iterator,
Repeat,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LoopRange {
pub start: CodeOffset,
pub end: CodeOffset,
pub line: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct StructIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct EnumIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct PatternIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct NamespaceRef(NonZeroU64);
impl NamespaceRef {
pub fn from_name(name: NameIdx) -> Self {
assert!(name.0 != u32::MAX, "namespace name index is reserved");
Self(NonZeroU64::new(u64::from(name.0) + 1).expect("non-zero name encoding"))
}
pub fn from_slot(name: NameIdx, slot: SlotIdx) -> Self {
assert!(name.0 != u32::MAX, "namespace name index is reserved");
assert!(slot.0 != u32::MAX, "namespace slot index is reserved");
let encoded = ((u64::from(slot.0) + 1) << 32) | u64::from(name.0);
Self(NonZeroU64::new(encoded).expect("non-zero slot encoding"))
}
pub fn name_idx(self) -> NameIdx {
let encoded = self.0.get();
if encoded <= u64::from(u32::MAX) {
NameIdx((encoded - 1) as u32)
} else {
NameIdx(encoded as u32)
}
}
pub fn slot_idx(self) -> Option<SlotIdx> {
let encoded = self.0.get();
if encoded <= u64::from(u32::MAX) {
None
} else {
Some(SlotIdx(((encoded >> 32) - 1) as u32))
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NamespaceIdx(NonZeroU32);
impl NamespaceIdx {
pub fn new(index: u32) -> Self {
Self(
NonZeroU32::new(index.checked_add(1).expect("namespace pool is too large"))
.expect("one-based namespace index"),
)
}
pub fn index(self) -> u32 {
self.0.get() - 1
}
}
#[cfg(test)]
mod instruction_layout_tests {
use super::{Instr, NameIdx, NamespaceIdx, NamespaceRef, SlotIdx};
#[test]
fn instruction_remains_three_machine_words() {
assert_eq!(core::mem::size_of::<Instr>(), 24);
assert_eq!(core::mem::size_of::<Option<NamespaceIdx>>(), 4);
}
#[test]
fn packed_namespace_references_round_trip() {
for name in [0, u32::MAX - 1] {
let namespace = NamespaceRef::from_name(NameIdx(name));
assert_eq!(namespace.name_idx(), NameIdx(name));
assert_eq!(namespace.slot_idx(), None);
for slot in [0, u32::MAX - 1] {
let namespace = NamespaceRef::from_slot(NameIdx(name), SlotIdx(slot));
assert_eq!(namespace.name_idx(), NameIdx(name));
assert_eq!(namespace.slot_idx(), Some(SlotIdx(slot)));
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct UseIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct LocalScopeIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ConstructFieldsIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CallSiteIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct PlaceIdx(pub u32);
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum EnumConstructShape {
Unit,
Tuple(u32),
Struct(u32),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AssignBack {
Slot(SlotIdx),
Name(NameIdx),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RefArgTarget {
Binding(NamespaceRef),
Place(PlaceIdx),
Invalid,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PlaceProjectionRecipe {
Index,
Field(NameIdx),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PlaceRecipe {
pub root: NamespaceRef,
pub projections: Vec<PlaceProjectionRecipe>,
}
#[derive(Debug, Clone)]
pub struct CallSite {
pub arg_modes: Vec<ParamMode>,
pub ref_targets: Vec<Option<RefArgTarget>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum InPlaceAssignOp {
Eq,
Add,
Sub,
Mul,
Div,
Rem,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Constant {
Int(i64),
Number(f64),
Str(String),
}
#[derive(Debug, Clone, PartialEq)]
pub enum InterpPart {
Literal(String),
Local(SlotIdx),
Name(NameIdx),
}
#[derive(Debug, Clone, PartialEq)]
pub struct InterpRecipe {
pub parts: Arc<[InterpPart]>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LocalScopeName {
pub name: NameIdx,
pub first_binding: u32,
}
#[derive(Debug, Clone, Default)]
pub struct LocalScopeNames {
pub binding_count: u32,
pub entries: Vec<LocalScopeName>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LocalScopeSnapshot {
pub scope: LocalScopeIdx,
pub binding_count: u32,
}
#[derive(Debug, Clone)]
pub struct UseSpec {
pub path: String,
pub items: Option<Vec<String>>,
pub alias: Option<String>,
pub local_scope: Option<LocalScopeSnapshot>,
}
#[derive(Debug, Clone, Default)]
pub struct Chunk {
pub code: Vec<Instr>,
pub lines: Vec<u32>,
pub constants: Vec<Constant>,
pub names: Vec<String>,
pub interps: Vec<InterpRecipe>,
pub functions: Vec<FnDef>,
pub struct_defs: Vec<StructDef>,
pub enum_defs: Vec<EnumDef>,
pub namespace_refs: Vec<NamespaceRef>,
pub construct_fields: Vec<Vec<String>>,
pub call_sites: Vec<CallSite>,
pub places: Vec<PlaceRecipe>,
pub patterns: Vec<PatternRecipe>,
pub use_specs: Vec<UseSpec>,
pub public_surface: Option<Vec<String>>,
pub local_scopes: Vec<LocalScopeNames>,
pub loop_ranges: Vec<LoopRange>,
pub slot_count: u32,
pub parameter_slots: Vec<SlotIdx>,
pub nesting_depth: u32,
}
#[derive(Debug, Clone)]
pub struct StructDef {
pub name: String,
pub fields: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct EnumDef {
pub name: String,
pub variants: Vec<EnumVariantDef>,
}
#[derive(Debug, Clone)]
pub struct EnumVariantDef {
pub name: String,
pub shape: EnumVariantShape,
}
#[derive(Debug, Clone, PartialEq)]
pub enum EnumVariantShape {
Unit,
Tuple(Vec<String>),
Struct(Vec<String>),
}
impl Chunk {
pub fn new() -> Self {
Self::default()
}
pub fn len(&self) -> usize {
self.code.len()
}
pub fn is_empty(&self) -> bool {
self.code.is_empty()
}
pub fn constant(&self, idx: ConstIdx) -> &Constant {
&self.constants[idx.0 as usize]
}
pub fn name(&self, idx: NameIdx) -> &str {
&self.names[idx.0 as usize]
}
pub fn interp(&self, idx: InterpIdx) -> &InterpRecipe {
&self.interps[idx.0 as usize]
}
pub fn function(&self, idx: FnIdx) -> &FnDef {
&self.functions[idx.0 as usize]
}
pub fn struct_def(&self, idx: StructIdx) -> &StructDef {
&self.struct_defs[idx.0 as usize]
}
pub fn enum_def(&self, idx: EnumIdx) -> &EnumDef {
&self.enum_defs[idx.0 as usize]
}
pub fn construct_fields(&self, idx: ConstructFieldsIdx) -> &[String] {
&self.construct_fields[idx.0 as usize]
}
pub fn call_site(&self, idx: CallSiteIdx) -> &CallSite {
&self.call_sites[idx.0 as usize]
}
pub fn place(&self, idx: PlaceIdx) -> &PlaceRecipe {
&self.places[idx.0 as usize]
}
pub fn namespace_ref(&self, idx: NamespaceIdx) -> NamespaceRef {
self.namespace_refs[idx.index() as usize]
}
pub fn pattern(&self, idx: PatternIdx) -> &PatternRecipe {
&self.patterns[idx.0 as usize]
}
pub fn use_spec(&self, idx: UseIdx) -> &UseSpec {
&self.use_specs[idx.0 as usize]
}
pub fn outermost_loop_line(&self, offset: CodeOffset) -> Option<u32> {
self.loop_ranges
.iter()
.filter(|range| range.start.0 <= offset.0 && offset.0 < range.end.0)
.min_by_key(|range| range.start.0)
.map(|range| range.line)
}
}
#[derive(Debug, Clone)]
pub struct PatternRecipe {
pub pattern: Arc<nybl::parser::Pattern>,
pub namespaces: Vec<(String, NamespaceRef)>,
}
#[derive(Debug, Clone)]
pub struct FnDef {
pub name: String,
pub params: Vec<String>,
pub param_modes: Vec<ParamMode>,
pub chunk: Arc<Chunk>,
pub slot_count: u32,
pub capture_names: Vec<String>,
pub capture_sources: Vec<CaptureSource>,
pub checks_import_clash: bool,
}
#[derive(Debug, Clone)]
pub enum CaptureSource {
ParentSlot(SlotIdx),
ParentScope(String),
}