git.delta.rocks / jrsonnet / refs/commits / b3f009bb7b2e

1use std::rc::Rc;2use std::{any::Any, cell::RefCell, future::Future};34use jrsonnet_gcmodule::Acyclic;5use jrsonnet_parser::{6	ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, ExprParam, ExprParams,7	FieldMember, FieldName, ForSpecData, IfElse, IfSpecData, ImportKind, ObjBody, ParserSettings,8	Slice, SliceDesc, Source, SourcePath, Spanned,9};10use rustc_hash::FxHashMap;1112use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, State};1314pub struct Import {15	path: ResolvePathOwned,16	expression: bool,17}1819pub struct FoundImports(Vec<Import>);2021// Visits all nodes, trying to find import statements22#[allow(clippy::too_many_lines)]23pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {24	fn in_destruct(dest: &Destruct, #[allow(unused_variables)] out: &mut FoundImports) {25		match dest {26			#[cfg(feature = "exp-destruct")]27			Destruct::Array {28				start,29				rest: _,30				end,31			} => {32				for dest in start {33					in_destruct(dest, out);34				}35				for dest in end {36					in_destruct(dest, out);37				}38			}39			#[cfg(feature = "exp-destruct")]40			Destruct::Object { fields, rest: _ } => {41				for (_, dest, default) in fields {42					if let Some(dest) = dest {43						in_destruct(dest, out);44					}45					if let Some(expr) = default {46						find_imports(expr, out);47					}48				}49			}50			#[cfg(feature = "exp-destruct")]51			Destruct::Skip => {}52			Destruct::Full(_) => {}53		}54	}55	fn in_compspec(specs: &[CompSpec], out: &mut FoundImports) {56		for spec in specs {57			match spec {58				CompSpec::IfSpec(IfSpecData(expr)) => find_imports(expr, out),59				CompSpec::ForSpec(ForSpecData(destruct, expr)) => {60					in_destruct(destruct, out);61					find_imports(expr, out);62				}63			}64		}65	}66	fn in_params(params: &ExprParams, out: &mut FoundImports) {67		for ExprParam { destruct, default } in &*params.exprs {68			in_destruct(destruct, out);69			if let Some(expr) = default {70				find_imports(expr, out);71			}72		}73	}74	fn in_bind(specs: &[BindSpec], out: &mut FoundImports) {75		for spec in specs {76			match spec {77				BindSpec::Field {78					into: dest,79					value: expr,80				} => {81					in_destruct(dest, out);82					find_imports(expr, out);83				}84				BindSpec::Function {85					name: _,86					params,87					value: expr,88				} => {89					in_params(params, out);90					find_imports(expr, out);91				}92			}93		}94	}95	fn in_args(ArgsDesc { unnamed, named }: &ArgsDesc, out: &mut FoundImports) {96		for expr in unnamed {97			find_imports(expr, out);98		}99		for (_, expr) in named {100			find_imports(expr, out);101		}102	}103	fn in_obj(obj: &ObjBody, out: &mut FoundImports) {104		match obj {105			ObjBody::MemberList(obj) => {106				for FieldMember {107					name,108					params,109					value,110					..111				} in &obj.fields112				{113					match name {114						FieldName::Fixed(_) => {}115						FieldName::Dyn(expr) => find_imports(expr, out),116					}117					if let Some(params) = params {118						in_params(params, out);119					}120					find_imports(value, out);121				}122				for _ in &*obj.locals {123					todo!()124				}125				for assert in &*obj.asserts {126					find_imports(&assert.0, out);127					if let Some(expr) = &assert.1 {128						find_imports(expr, out);129					}130				}131			}132			ObjBody::ObjComp(_) => todo!(),133		}134	}135	match &**expr {136		Expr::Import(_, v) => {137			if let Expr::Str(s) = &***v {138				out.0.push(Import {139					path: ResolvePathOwned::Str(s.to_string()),140					expression: matches!(&**expr, Expr::Import(ImportKind::Normal, _)),141				});142			}143			// Non-string import will fail in runtime144		}145146		Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}147148		Expr::Arr(arr) => {149			for expr in &**arr {150				find_imports(expr, out);151			}152		}153		Expr::ArrComp(expr, specs) => {154			find_imports(expr, out);155			in_compspec(specs, out);156		}157		Expr::Obj(obj) => in_obj(obj, out),158		Expr::ObjExtend(expr, obj) => {159			find_imports(expr, out);160			in_obj(obj, out);161		}162		Expr::BinaryOp(binop) => {163			find_imports(&binop.lhs, out);164			find_imports(&binop.rhs, out);165		}166		Expr::AssertExpr(assert) => {167			let AssertExpr {168				assert: AssertStmt(expr, expr2),169				rest,170			} = &**assert;171			find_imports(expr, out);172			if let Some(expr) = expr2 {173				find_imports(expr, out);174			}175			find_imports(rest, out);176		}177		Expr::LocalExpr(specs, expr) => {178			in_bind(specs, out);179			find_imports(expr, out);180		}181		Expr::Apply(expr, args, _) => {182			find_imports(expr, out);183			in_args(args, out);184		}185		Expr::Index { indexable, parts } => {186			find_imports(indexable, out);187			for part in parts {188				find_imports(&part.value, out);189			}190		}191		Expr::Function(params, expr) => {192			in_params(params, out);193			find_imports(expr, out);194		}195		Expr::IfElse(if_else) => {196			let IfElse {197				cond: IfSpecData(expr),198				cond_then,199				cond_else,200			} = &**if_else;201			find_imports(expr, out);202			find_imports(cond_then, out);203			if let Some(expr) = cond_else {204				find_imports(expr, out);205			}206		}207		Expr::Slice(slice) => {208			let Slice {209				value,210				slice: SliceDesc { start, end, step },211			} = &**slice;212			find_imports(value, out);213			if let Some(expr) = start {214				find_imports(expr, out);215			}216			if let Some(expr) = end {217				find_imports(expr, out);218			}219			if let Some(expr) = step {220				find_imports(expr, out);221			}222		}223		Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {224			find_imports(expr, out);225		}226	}227}228229pub trait AsyncImportResolver {230	type Error;231	/// Resolves file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond232	/// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`233	/// where `${vendor}` is a library path.234	///235	/// `from` should only be returned from [`ImportResolver::resolve`],236	/// or from other defined file, any other value may result in panic237	fn resolve_from(238		&self,239		from: &SourcePath,240		path: &dyn AsPathLike,241	) -> impl Future<Output = Result<SourcePath, Self::Error>>;242	fn resolve_from_default(243		&self,244		path: &dyn AsPathLike,245	) -> impl Future<Output = Result<SourcePath, Self::Error>> {246		async { self.resolve_from(&SourcePath::default(), path).await }247	}248249	/// Load resolved file250	/// This should only be called with value returned251	/// from [`ImportResolver::resolve_file`]/[`ImportResolver::resolve`],252	/// this cannot be resolved using associated type,253	/// as the evaluator uses object instead of generic for [`ImportResolver`]254	fn load_file_contents(255		&self,256		resolved: &SourcePath,257	) -> impl Future<Output = Result<Vec<u8>, Self::Error>>;258}259260#[derive(Acyclic)]261struct ResolvedImportResolver {262	resolved: RefCell<FxHashMap<(SourcePath, ResolvePathOwned), (SourcePath, bool)>>,263}264impl ImportResolver for ResolvedImportResolver {265	fn load_file_contents(&self, _resolved: &SourcePath) -> crate::Result<Vec<u8>> {266		unreachable!("all files should be loaded at this point");267	}268269	fn resolve_from(&self, from: &SourcePath, path: &dyn AsPathLike) -> crate::Result<SourcePath> {270		Ok(self271			.resolved272			.borrow()273			.get(&(from.clone(), path.as_path().to_owned()))274			.expect("all imports should be resolved at this point")275			.0276			.clone())277	}278279	fn resolve_from_default(&self, path: &dyn AsPathLike) -> crate::Result<SourcePath> {280		self.resolve_from(&SourcePath::default(), path)281	}282}283284enum Job {285	LoadFile { path: SourcePath, parse: bool },286	ParseFile(SourcePath),287	ResolveImport { from: SourcePath, import: Import },288}289290#[allow(clippy::future_not_send)]291pub async fn async_import<H>(s: State, handler: H, path: &dyn AsPathLike) -> Result<(), H::Error>292where293	H: AsyncImportResolver,294{295	let resolved = (s.import_resolver() as &dyn Any)296		.downcast_ref::<ResolvedImportResolver>()297		.expect("for async imports, import_resolver should be set to ResolvedImportResolver");298299	let mut resolved_map = resolved.resolved.borrow_mut();300301	let mut queue = vec![Job::LoadFile {302		path: handler.resolve_from_default(path).await?,303		parse: true,304	}];305	while let Some(job) = queue.pop() {306		match job {307			Job::LoadFile { path, parse } => {308				if !s.0.file_cache.borrow().contains_key(&path) {309					let data = handler.load_file_contents(&path).await?;310					s.0.file_cache311						.borrow_mut()312						.insert(path.clone(), FileData::new_bytes(data.as_slice().into()));313				}314				if parse {315					queue.push(Job::ParseFile(path));316				}317			}318			Job::ParseFile(path) => {319				if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {320					if file.parsed.is_none() {321						let Some(code) = file.get_string() else {322							continue;323						};324						let source = Source::new(path.clone(), code.clone());325						// If failed - then skip import326						file.parsed = jrsonnet_parser::parse(&code, &ParserSettings { source })327							.map(Rc::new)328							.ok();329						if let Some(parsed) = &file.parsed {330							let mut imports = FoundImports(vec![]);331							find_imports(parsed, &mut imports);332							for import in imports.0 {333								queue.push(Job::ResolveImport {334									from: path.clone(),335									import,336								});337							}338						}339					}340				}341			}342			Job::ResolveImport { from, import } => {343				if let Some((resolved, expression)) =344					resolved_map.get_mut(&(from.clone(), import.path.clone()))345				{346					if import.expression && !*expression {347						*expression = true;348						queue.push(Job::ParseFile(resolved.clone()));349					}350					continue;351				}352				let resolved = handler.resolve_from(&from, &import.path).await?;353				queue.push(Job::LoadFile {354					path: resolved,355					parse: import.expression,356				});357			}358		}359	}360	Ok(())361}