git.delta.rocks / jrsonnet / refs/commits / 325f0a12bbb7

1use std::{2	fmt::{self, Debug, Display},3	ops::Deref,4	rc::Rc,5};67use jrsonnet_gcmodule::Acyclic;8use jrsonnet_interner::IStr;910use crate::{11	function::{FunctionSignature, ParamDefault, ParamName, ParamParse},12	source::Source,13};1415#[derive(Debug, PartialEq, Acyclic)]16pub enum FieldName {17	/// {fixed: 2}18	Fixed(IStr),19	/// {["dyn"+"amic"]: 3}20	Dyn(Expr),21}2223#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]24#[repr(u8)]25pub enum Visibility {26	/// :27	Normal,28	/// ::29	Hidden,30	/// :::31	Unhide,32}3334impl Visibility {35	pub fn is_visible(&self) -> bool {36		matches!(self, Self::Normal | Self::Unhide)37	}38}3940#[derive(Debug, PartialEq, Acyclic)]41pub struct AssertStmt(pub Spanned<Expr>, pub Option<Spanned<Expr>>);4243#[derive(Debug, PartialEq, Acyclic)]44pub struct FieldMember {45	pub name: Spanned<FieldName>,46	pub plus: bool,47	pub params: Option<ExprParams>,48	pub visibility: Visibility,49	pub value: Rc<Expr>,50}5152#[derive(Debug, PartialEq, Acyclic)]53pub enum Member {54	Field(FieldMember),55	BindStmt(BindSpec),56	AssertStmt(AssertStmt),57}5859#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]60pub enum UnaryOpType {61	Plus,62	Minus,63	BitNot,64	Not,65}6667impl Display for UnaryOpType {68	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {69		use UnaryOpType::*;70		write!(71			f,72			"{}",73			match self {74				Plus => "+",75				Minus => "-",76				BitNot => "~",77				Not => "!",78			}79		)80	}81}8283#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]84pub enum BinaryOpType {85	Mul,86	Div,8788	/// Implemented as intrinsic, put here for completeness89	Mod,9091	Add,92	Sub,9394	Lhs,95	Rhs,9697	Lt,98	Gt,99	Lte,100	Gte,101102	BitAnd,103	BitOr,104	BitXor,105106	Eq,107	Neq,108109	And,110	Or,111	#[cfg(feature = "exp-null-coaelse")]112	NullCoaelse,113114	// Equialent to std.objectHasEx(a, b, true)115	In,116}117118impl Display for BinaryOpType {119	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {120		use BinaryOpType::*;121		write!(122			f,123			"{}",124			match self {125				Mul => "*",126				Div => "/",127				Mod => "%",128				Add => "+",129				Sub => "-",130				Lhs => "<<",131				Rhs => ">>",132				Lt => "<",133				Gt => ">",134				Lte => "<=",135				Gte => ">=",136				BitAnd => "&",137				BitOr => "|",138				BitXor => "^",139				Eq => "==",140				Neq => "!=",141				And => "&&",142				Or => "||",143				In => "in",144				#[cfg(feature = "exp-null-coaelse")]145				NullCoaelse => "??",146			}147		)148	}149}150151/// name, default value152#[derive(Debug, PartialEq, Acyclic)]153pub struct ExprParam {154	pub destruct: Destruct,155	pub default: Option<Rc<Expr>>,156}157158/// Defined function parameters159#[derive(Debug, Clone, PartialEq, Acyclic)]160pub struct ExprParams {161	pub exprs: Rc<Vec<ExprParam>>,162	pub signature: FunctionSignature,163	binds_len: usize,164}165impl ExprParams {166	pub fn len(&self) -> usize {167		self.exprs.len()168	}169	pub fn is_empty(&self) -> bool {170		self.exprs.is_empty()171	}172173	pub fn binds_len(&self) -> usize {174		self.binds_len175	}176	pub fn new(exprs: Vec<ExprParam>) -> Self {177		Self {178			signature: FunctionSignature::new(179				exprs180					.iter()181					.map(|p| {182						ParamParse::new(183							p.destruct.name(),184							ParamDefault::exists(p.default.is_some()),185						)186					})187					.collect(),188			),189			binds_len: exprs.iter().map(|v| v.destruct.binds_len()).sum(),190			exprs: Rc::new(exprs),191		}192	}193}194195#[derive(Debug, PartialEq, Acyclic)]196pub struct ArgsDesc {197	pub unnamed: Vec<Rc<Expr>>,198	pub named: Vec<(IStr, Rc<Expr>)>,199}200impl ArgsDesc {201	pub fn new(unnamed: Vec<Rc<Expr>>, named: Vec<(IStr, Rc<Expr>)>) -> Self {202		Self { unnamed, named }203	}204}205206#[derive(Debug, Clone, PartialEq, Eq, Acyclic)]207pub enum DestructRest {208	/// ...rest209	Keep(IStr),210	/// ...211	Drop,212}213214#[derive(Debug, Clone, PartialEq, Acyclic)]215pub enum Destruct {216	Full(IStr),217	#[cfg(feature = "exp-destruct")]218	Skip,219	#[cfg(feature = "exp-destruct")]220	Array {221		start: Vec<Destruct>,222		rest: Option<DestructRest>,223		end: Vec<Destruct>,224	},225	#[cfg(feature = "exp-destruct")]226	Object {227		#[allow(clippy::type_complexity)]228		fields: Vec<(IStr, Option<Destruct>, Option<Rc<Spanned<Expr>>>)>,229		rest: Option<DestructRest>,230	},231}232impl Destruct {233	/// Name of destructure, used for function parameter names234	pub fn name(&self) -> ParamName {235		match self {236			Self::Full(name) => ParamName::Named(name.clone()),237			#[cfg(feature = "exp-destruct")]238			_ => ParamName::Unnamed,239		}240	}241	pub fn binds_len(&self) -> usize {242		#[cfg(feature = "exp-destruct")]243		fn cap_rest(rest: &Option<DestructRest>) -> usize {244			match rest {245				Some(DestructRest::Keep(_)) => 1,246				Some(DestructRest::Drop) => 0,247				None => 0,248			}249		}250		match self {251			Self::Full(_) => 1,252			#[cfg(feature = "exp-destruct")]253			Self::Skip => 0,254			#[cfg(feature = "exp-destruct")]255			Self::Array { start, rest, end } => {256				start.iter().map(Destruct::binds_len).sum::<usize>()257					+ end.iter().map(Destruct::binds_len).sum::<usize>()258					+ cap_rest(rest)259			}260			#[cfg(feature = "exp-destruct")]261			Self::Object { fields, rest } => {262				let mut out = 0;263				for (_, into, _) in fields {264					match into {265						Some(v) => out += v.binds_len(),266						// Field is destructured to default name267						None => out += 1,268					}269				}270				out + cap_rest(rest)271			}272		}273	}274}275276#[derive(Debug, PartialEq, Acyclic)]277pub enum BindSpec {278	Field {279		into: Destruct,280		value: Rc<Expr>,281	},282	Function {283		name: IStr,284		params: ExprParams,285		value: Rc<Expr>,286	},287}288impl BindSpec {289	pub fn binds_len(&self) -> usize {290		match self {291			BindSpec::Field { into, .. } => into.binds_len(),292			BindSpec::Function { .. } => 1,293		}294	}295}296297#[derive(Debug, PartialEq, Acyclic)]298pub struct IfSpecData {299	pub span: Span,300	pub cond: Expr,301}302303#[derive(Debug, PartialEq, Acyclic)]304pub struct ForSpecData {305	pub destruct: Destruct,306	pub over: Expr,307}308309#[derive(Debug, PartialEq, Acyclic)]310pub enum CompSpec {311	IfSpec(IfSpecData),312	ForSpec(ForSpecData),313}314315#[derive(Debug, PartialEq, Acyclic)]316pub struct ObjComp {317	pub locals: Rc<Vec<BindSpec>>,318	pub field: Rc<FieldMember>,319	pub compspecs: Vec<CompSpec>,320}321322#[derive(Debug, PartialEq, Acyclic)]323pub struct ObjMembers {324	pub locals: Rc<Vec<BindSpec>>,325	pub asserts: Rc<Vec<AssertStmt>>,326	pub fields: Vec<FieldMember>,327}328329#[derive(Debug, PartialEq, Acyclic)]330pub enum ObjBody {331	MemberList(ObjMembers),332	ObjComp(ObjComp),333}334335#[derive(Debug, PartialEq, Eq, Clone, Copy, Acyclic)]336pub enum LiteralType {337	This,338	Super,339	Dollar,340	Null,341	True,342	False,343}344345#[derive(Debug, PartialEq, Acyclic)]346pub struct SliceDesc {347	pub start: Option<Spanned<Expr>>,348	pub end: Option<Spanned<Expr>>,349	pub step: Option<Spanned<Expr>>,350}351352#[derive(Debug, PartialEq, Acyclic)]353pub struct AssertExpr {354	pub assert: AssertStmt,355	pub rest: Expr,356}357358#[derive(Debug, PartialEq, Acyclic)]359pub struct BinaryOp {360	pub lhs: Expr,361	pub op: BinaryOpType,362	pub rhs: Expr,363}364365#[derive(Debug, PartialEq, Acyclic)]366pub enum ImportKind {367	Normal,368	Str,369	Bin,370}371372#[derive(Debug, PartialEq, Acyclic)]373pub struct IfElse {374	pub cond: IfSpecData,375	pub cond_then: Expr,376	pub cond_else: Option<Expr>,377}378379#[derive(Debug, PartialEq, Acyclic)]380pub struct Slice {381	pub value: Expr,382	pub slice: SliceDesc,383}384385/// Syntax base386#[derive(Debug, PartialEq, Acyclic)]387pub enum Expr {388	Literal(LiteralType),389390	/// String value: "hello"391	Str(IStr),392	/// Number: 1, 2.0, 2e+20393	Num(f64),394	/// Variable name: test395	Var(Spanned<IStr>),396397	/// Array of expressions: [1, 2, "Hello"]398	Arr(Rc<Vec<Expr>>),399	/// Array comprehension:400	/// ```jsonnet401	///  ingredients: [402	///    { kind: kind, qty: 4 / 3 }403	///    for kind in [404	///      'Honey Syrup',405	///      'Lemon Juice',406	///      'Farmers Gin',407	///    ]408	///  ],409	/// ```410	ArrComp(Rc<Expr>, Vec<CompSpec>),411412	/// Object: {a: 2}413	Obj(ObjBody),414	/// Object extension: var1 {b: 2}415	ObjExtend(Rc<Expr>, ObjBody),416417	/// -2418	UnaryOp(UnaryOpType, Box<Expr>),419	/// 2 - 2420	BinaryOp(Box<BinaryOp>),421	/// assert 2 == 2 : "Math is broken"422	AssertExpr(Rc<AssertExpr>),423	/// local a = 2; { b: a }424	LocalExpr(Vec<BindSpec>, Box<Expr>),425426	/// import* "hello"427	Import(Spanned<ImportKind>, Box<Expr>),428	/// error "I'm broken"429	ErrorStmt(Span, Box<Expr>),430	/// a(b, c)431	Apply(Box<Expr>, Spanned<ArgsDesc>, bool),432	/// a[b], a.b, a?.b433	Index {434		indexable: Box<Expr>,435		parts: Vec<IndexPart>,436	},437	/// function(x) x438	Function(ExprParams, Rc<Expr>),439	/// if true == false then 1 else 2440	IfElse(Box<IfElse>),441	Slice(Box<Slice>),442}443444#[derive(Debug, PartialEq, Acyclic)]445pub struct IndexPart {446	pub span: Span,447	pub value: Expr,448	#[cfg(feature = "exp-null-coaelse")]449	pub null_coaelse: bool,450}451452/// file, begin offset, end offset453#[derive(Clone, PartialEq, Eq, Acyclic)]454#[repr(C)]455pub struct Span(pub Source, pub u32, pub u32);456impl Span {457	pub fn belongs_to(&self, other: &Span) -> bool {458		other.0 == self.0 && other.1 <= self.1 && other.2 >= self.2459	}460}461462static_assertions::assert_eq_size!(Span, (usize, usize));463464impl Debug for Span {465	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {466		write!(f, "{:?}:{:?}-{:?}", self.0, self.1, self.2)467	}468}469470#[derive(Clone, PartialEq, Acyclic)]471pub struct Spanned<T: Acyclic> {472	pub value: T,473	pub span: Span,474}475impl<T: Acyclic> Deref for Spanned<T> {476	type Target = T;477	fn deref(&self) -> &Self::Target {478		&self.value479	}480}481impl<T: Acyclic> Spanned<T> {482	#[inline]483	pub fn new(value: T, span: Span) -> Self {484		Self { value, span }485	}486}487488impl<T: Debug + Acyclic> Debug for Spanned<T> {489	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {490		let expr = &**self;491		if f.alternate() {492			write!(f, "{:#?}", expr)?;493		} else {494			write!(f, "{:?}", expr)?;495		}496		write!(f, " from {:?}", self.span)?;497		Ok(())498	}499}