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

1use std::{cell::RefCell, path::Path};23use async_trait::async_trait;4use jrsonnet_gcmodule::Trace;5use jrsonnet_interner::IStr;6use jrsonnet_parser::{7	ArgsDesc, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, FieldName, ForSpecData,8	IfSpecData, LocExpr, Member, ObjBody, Param, ParamsDesc, ParserSettings, SliceDesc, Source,9	SourcePath,10};1112use crate::{bail, gc::GcHashMap, FileData, ImportResolver, State};1314pub struct Import {15	path: IStr,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: &LocExpr, 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: &ParamsDesc, out: &mut FoundImports) {67		for Param(dest, default) in &*params.0 {68			in_destruct(dest, 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(v) => {106				for member in v {107					match member {108						Member::Field(FieldMember {109							name,110							params,111							value,112							..113						}) => {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						Member::BindStmt(_) => todo!(),124						Member::AssertStmt(AssertStmt(expr, expr2)) => {125							find_imports(expr, out);126							if let Some(expr) = expr2 {127								find_imports(expr, out);128							}129						}130					}131				}132			}133			ObjBody::ObjComp(_) => todo!(),134		}135	}136	match &*expr.0 {137		Expr::Import(v) | Expr::ImportStr(v) | Expr::ImportBin(v) => {138			if let Expr::Str(s) = &*v.0 {139				out.0.push(Import {140					path: s.clone(),141					expression: matches!(&*expr.0, Expr::Import(_)),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(a, _, b) => {164			find_imports(a, out);165			find_imports(b, out);166		}167		Expr::AssertExpr(AssertStmt(expr, expr2), then) => {168			find_imports(expr, out);169			if let Some(expr) = expr2 {170				find_imports(expr, out);171			}172			find_imports(then, out);173		}174		Expr::LocalExpr(specs, expr) => {175			in_bind(specs, out);176			find_imports(expr, out);177		}178		Expr::Apply(expr, args, _) => {179			find_imports(expr, out);180			in_args(args, out);181		}182		Expr::Index { indexable, parts } => {183			find_imports(indexable, out);184			for part in parts {185				find_imports(&part.value, out);186			}187		}188		Expr::Function(params, expr) => {189			in_params(params, out);190			find_imports(expr, out);191		}192		Expr::IfElse {193			cond: IfSpecData(expr),194			cond_then,195			cond_else,196		} => {197			find_imports(expr, out);198			find_imports(cond_then, out);199			if let Some(expr) = cond_else {200				find_imports(expr, out);201			}202		}203		Expr::Slice(expr, SliceDesc { start, end, step }) => {204			find_imports(expr, out);205			if let Some(expr) = start {206				find_imports(expr, out);207			}208			if let Some(expr) = end {209				find_imports(expr, out);210			}211			if let Some(expr) = step {212				find_imports(expr, out);213			}214		}215		Expr::Parened(expr) | Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {216			find_imports(expr, out);217		}218	}219}220221#[async_trait(?Send)]222pub trait AsyncImportResolver {223	type Error;224	/// Resolves file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond225	/// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`226	/// where `${vendor}` is a library path.227	///228	/// `from` should only be returned from [`ImportResolver::resolve`], or from other defined file, any other value229	/// may result in panic230	async fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath, Self::Error>;231	async fn resolve_from_default(&self, path: &str) -> Result<SourcePath, Self::Error> {232		self.resolve_from(&SourcePath::default(), path).await233	}234	/// Resolves absolute path, doesn't supports jpath and other fancy things235	async fn resolve(&self, path: &Path) -> Result<SourcePath, Self::Error>;236237	/// Load resolved file238	/// This should only be called with value returned from [`ImportResolver::resolve_file`]/[`ImportResolver::resolve`],239	/// this cannot be resolved using associated type, as evaluator uses object instead of generic for [`ImportResolver`]240	async fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>, Self::Error>;241}242243#[derive(Trace)]244struct ResolvedImportResolver {245	resolved: RefCell<GcHashMap<(SourcePath, IStr), (SourcePath, bool)>>,246}247impl ImportResolver for ResolvedImportResolver {248	fn load_file_contents(&self, _resolved: &SourcePath) -> crate::Result<Vec<u8>> {249		unreachable!("all files should be loaded at this point");250	}251252	fn resolve_from(&self, from: &SourcePath, path: &str) -> crate::Result<SourcePath> {253		Ok(self254			.resolved255			.borrow()256			.get(&(from.clone(), path.into()))257			.expect("all imports should be resolved at this point")258			.0259			.clone())260	}261262	fn resolve_from_default(&self, path: &str) -> crate::Result<SourcePath> {263		self.resolve_from(&SourcePath::default(), path)264	}265266	fn resolve(&self, path: &Path) -> crate::Result<SourcePath> {267		bail!(crate::error::ErrorKind::AbsoluteImportNotSupported(268			path.to_owned()269		))270	}271272	fn as_any(&self) -> &dyn std::any::Any {273		self274	}275}276277enum Job {278	LoadFile { path: SourcePath, parse: bool },279	ParseFile(SourcePath),280	ResolveImport { from: SourcePath, import: Import },281}282283#[allow(clippy::future_not_send)]284pub async fn async_import<H>(s: State, handler: H, path: impl AsRef<Path>) -> Result<(), H::Error>285where286	H: AsyncImportResolver,287{288	let mut resolved = s289		.import_resolver()290		.as_any()291		.downcast_ref::<ResolvedImportResolver>()292		.map_or_else(GcHashMap::new, |resolver| {293			std::mem::take(&mut *resolver.resolved.borrow_mut())294		});295	let mut queue = vec![Job::LoadFile {296		path: handler.resolve(path.as_ref()).await?,297		parse: true,298	}];299	while let Some(job) = queue.pop() {300		match job {301			Job::LoadFile { path, parse } => {302				if !s.0.file_cache.borrow().contains_key(&path) {303					let data = handler.load_file_contents(&path).await?;304					s.0.file_cache305						.borrow_mut()306						.insert(path.clone(), FileData::new_bytes(data.as_slice().into()));307				}308				if parse {309					queue.push(Job::ParseFile(path));310				}311			}312			Job::ParseFile(path) => {313				if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {314					if file.parsed.is_none() {315						let Some(code) = file.get_string() else {316							continue;317						};318						let source = Source::new(path.clone(), code.clone());319						// If failed - then skip import320						file.parsed =321							jrsonnet_parser::parse(&code, &ParserSettings { source }).ok();322						if let Some(parsed) = &file.parsed {323							let mut imports = FoundImports(vec![]);324							find_imports(parsed, &mut imports);325							for import in imports.0 {326								queue.push(Job::ResolveImport {327									from: path.clone(),328									import,329								});330							}331						}332					}333				}334			}335			Job::ResolveImport { from, import } => {336				if let Some((resolved, expression)) =337					resolved.get_mut(&(from.clone(), import.path.clone()))338				{339					if import.expression && !*expression {340						*expression = true;341						queue.push(Job::ParseFile(resolved.clone()));342					}343					continue;344				}345				let resolved = handler.resolve_from(&from, &import.path).await?;346				queue.push(Job::LoadFile {347					path: resolved,348					parse: import.expression,349				});350			}351		}352	}353	s.set_import_resolver(ResolvedImportResolver {354		resolved: RefCell::new(resolved),355	});356	Ok(())357}