git.delta.rocks / jrsonnet / refs/commits / 94c438bdfffb

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