1use std::{cell::RefCell, future::Future, path::Path};23use jrsonnet_gcmodule::Trace;4use jrsonnet_interner::IStr;5use jrsonnet_parser::{6 ArgsDesc, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, FieldName, ForSpecData,7 IfSpecData, LocExpr, Member, ObjBody, Param, ParamsDesc, ParserSettings, SliceDesc, Source,8 SourcePath,9};1011use crate::{bail, gc::GcHashMap, FileData, ImportResolver, State};1213pub struct Import {14 path: IStr,15 expression: bool,16}1718pub struct FoundImports(Vec<Import>);192021#[allow(clippy::too_many_lines)]22pub fn find_imports(expr: &LocExpr, out: &mut FoundImports) {23 fn in_destruct(dest: &Destruct, #[allow(unused_variables)] out: &mut FoundImports) {24 match dest {25 #[cfg(feature = "exp-destruct")]26 Destruct::Array {27 start,28 rest: _,29 end,30 } => {31 for dest in start {32 in_destruct(dest, out);33 }34 for dest in end {35 in_destruct(dest, out);36 }37 }38 #[cfg(feature = "exp-destruct")]39 Destruct::Object { fields, rest: _ } => {40 for (_, dest, default) in fields {41 if let Some(dest) = dest {42 in_destruct(dest, out);43 }44 if let Some(expr) = default {45 find_imports(expr, out);46 }47 }48 }49 #[cfg(feature = "exp-destruct")]50 Destruct::Skip => {}51 Destruct::Full(_) => {}52 }53 }54 fn in_compspec(specs: &[CompSpec], out: &mut FoundImports) {55 for spec in specs {56 match spec {57 CompSpec::IfSpec(IfSpecData(expr)) => find_imports(expr, out),58 CompSpec::ForSpec(ForSpecData(destruct, expr)) => {59 in_destruct(destruct, out);60 find_imports(expr, out);61 }62 }63 }64 }65 fn in_params(params: &ParamsDesc, out: &mut FoundImports) {66 for Param(dest, default) in &*params.0 {67 in_destruct(dest, out);68 if let Some(expr) = default {69 find_imports(expr, out);70 }71 }72 }73 fn in_bind(specs: &[BindSpec], out: &mut FoundImports) {74 for spec in specs {75 match spec {76 BindSpec::Field {77 into: dest,78 value: expr,79 } => {80 in_destruct(dest, out);81 find_imports(expr, out);82 }83 BindSpec::Function {84 name: _,85 params,86 value: expr,87 } => {88 in_params(params, out);89 find_imports(expr, out);90 }91 }92 }93 }94 fn in_args(ArgsDesc { unnamed, named }: &ArgsDesc, out: &mut FoundImports) {95 for expr in unnamed {96 find_imports(expr, out);97 }98 for (_, expr) in named {99 find_imports(expr, out);100 }101 }102 fn in_obj(obj: &ObjBody, out: &mut FoundImports) {103 match obj {104 ObjBody::MemberList(v) => {105 for member in v {106 match member {107 Member::Field(FieldMember {108 name,109 params,110 value,111 ..112 }) => {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 Member::BindStmt(_) => todo!(),123 Member::AssertStmt(AssertStmt(expr, expr2)) => {124 find_imports(expr, out);125 if let Some(expr) = expr2 {126 find_imports(expr, out);127 }128 }129 }130 }131 }132 ObjBody::ObjComp(_) => todo!(),133 }134 }135 match &*expr.0 {136 Expr::Import(v) | Expr::ImportStr(v) | Expr::ImportBin(v) => {137 if let Expr::Str(s) = &*v.0 {138 out.0.push(Import {139 path: s.clone(),140 expression: matches!(&*expr.0, Expr::Import(_)),141 });142 }143 144 }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(a, _, b) => {163 find_imports(a, out);164 find_imports(b, out);165 }166 Expr::AssertExpr(AssertStmt(expr, expr2), then) => {167 find_imports(expr, out);168 if let Some(expr) = expr2 {169 find_imports(expr, out);170 }171 find_imports(then, out);172 }173 Expr::LocalExpr(specs, expr) => {174 in_bind(specs, out);175 find_imports(expr, out);176 }177 Expr::Apply(expr, args, _) => {178 find_imports(expr, out);179 in_args(args, out);180 }181 Expr::Index { indexable, parts } => {182 find_imports(indexable, out);183 for part in parts {184 find_imports(&part.value, out);185 }186 }187 Expr::Function(params, expr) => {188 in_params(params, out);189 find_imports(expr, out);190 }191 Expr::IfElse {192 cond: IfSpecData(expr),193 cond_then,194 cond_else,195 } => {196 find_imports(expr, out);197 find_imports(cond_then, out);198 if let Some(expr) = cond_else {199 find_imports(expr, out);200 }201 }202 Expr::Slice(expr, SliceDesc { start, end, step }) => {203 find_imports(expr, out);204 if let Some(expr) = start {205 find_imports(expr, out);206 }207 if let Some(expr) = end {208 find_imports(expr, out);209 }210 if let Some(expr) = step {211 find_imports(expr, out);212 }213 }214 Expr::Parened(expr) | Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {215 find_imports(expr, out);216 }217 }218}219220pub trait AsyncImportResolver {221 type Error;222 223 224 225 226 227 228 fn resolve_from(229 &self,230 from: &SourcePath,231 path: &str,232 ) -> impl Future<Output = Result<SourcePath, Self::Error>>;233 fn resolve_from_default(234 &self,235 path: &str,236 ) -> impl Future<Output = Result<SourcePath, Self::Error>> {237 async { self.resolve_from(&SourcePath::default(), path).await }238 }239 240 fn resolve(&self, path: &Path) -> impl Future<Output = Result<SourcePath, Self::Error>>;241242 243 244 245 246 247 fn load_file_contents(248 &self,249 resolved: &SourcePath,250 ) -> impl Future<Output = Result<Vec<u8>, Self::Error>>;251}252253#[derive(Trace)]254struct ResolvedImportResolver {255 resolved: RefCell<GcHashMap<(SourcePath, IStr), (SourcePath, bool)>>,256}257impl ImportResolver for ResolvedImportResolver {258 fn load_file_contents(&self, _resolved: &SourcePath) -> crate::Result<Vec<u8>> {259 unreachable!("all files should be loaded at this point");260 }261262 fn resolve_from(&self, from: &SourcePath, path: &str) -> crate::Result<SourcePath> {263 Ok(self264 .resolved265 .borrow()266 .get(&(from.clone(), path.into()))267 .expect("all imports should be resolved at this point")268 .0269 .clone())270 }271272 fn resolve_from_default(&self, path: &str) -> crate::Result<SourcePath> {273 self.resolve_from(&SourcePath::default(), path)274 }275276 fn resolve(&self, path: &Path) -> crate::Result<SourcePath> {277 bail!(crate::error::ErrorKind::AbsoluteImportNotSupported(278 path.to_owned()279 ))280 }281282 fn as_any(&self) -> &dyn std::any::Any {283 self284 }285}286287enum Job {288 LoadFile { path: SourcePath, parse: bool },289 ParseFile(SourcePath),290 ResolveImport { from: SourcePath, import: Import },291}292293#[allow(clippy::future_not_send)]294pub async fn async_import<H>(s: State, handler: H, path: impl AsRef<Path>) -> Result<(), H::Error>295where296 H: AsyncImportResolver,297{298 let mut resolved = s299 .import_resolver()300 .as_any()301 .downcast_ref::<ResolvedImportResolver>()302 .map_or_else(GcHashMap::new, |resolver| {303 std::mem::take(&mut *resolver.resolved.borrow_mut())304 });305 let mut queue = vec![Job::LoadFile {306 path: handler.resolve(path.as_ref()).await?,307 parse: true,308 }];309 while let Some(job) = queue.pop() {310 match job {311 Job::LoadFile { path, parse } => {312 if !s.0.file_cache.borrow().contains_key(&path) {313 let data = handler.load_file_contents(&path).await?;314 s.0.file_cache315 .borrow_mut()316 .insert(path.clone(), FileData::new_bytes(data.as_slice().into()));317 }318 if parse {319 queue.push(Job::ParseFile(path));320 }321 }322 Job::ParseFile(path) => {323 if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {324 if file.parsed.is_none() {325 let Some(code) = file.get_string() else {326 continue;327 };328 let source = Source::new(path.clone(), code.clone());329 330 file.parsed =331 jrsonnet_parser::parse(&code, &ParserSettings { source }).ok();332 if let Some(parsed) = &file.parsed {333 let mut imports = FoundImports(vec![]);334 find_imports(parsed, &mut imports);335 for import in imports.0 {336 queue.push(Job::ResolveImport {337 from: path.clone(),338 import,339 });340 }341 }342 }343 }344 }345 Job::ResolveImport { from, import } => {346 if let Some((resolved, expression)) =347 resolved.get_mut(&(from.clone(), import.path.clone()))348 {349 if import.expression && !*expression {350 *expression = true;351 queue.push(Job::ParseFile(resolved.clone()));352 }353 continue;354 }355 let resolved = handler.resolve_from(&from, &import.path).await?;356 queue.push(Job::LoadFile {357 path: resolved,358 parse: import.expression,359 });360 }361 }362 }363 s.set_import_resolver(ResolvedImportResolver {364 resolved: RefCell::new(resolved),365 });366 Ok(())367}