difftreelog
style move `#[allow(async_fn_in_trait)]` comment to the top
in: master
1 file changed
crates/jrsonnet-evaluator/src/async_import.rsdiffbeforeafterboth1use std::{cell::RefCell, 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>);1920// Visits all nodes, trying to find import statements21#[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 // 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(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}219220#[allow(async_fn_in_trait)] // we don't care about `Send` bound221pub trait AsyncImportResolver {222 type Error;223 /// Resolves file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond224 /// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`225 /// where `${vendor}` is a library path.226 ///227 /// `from` should only be returned from [`ImportResolver::resolve`], or from other defined file, any other value228 /// may result in panic229 async fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath, Self::Error>;230 async fn resolve_from_default(&self, path: &str) -> Result<SourcePath, Self::Error> {231 self.resolve_from(&SourcePath::default(), path).await232 }233 /// Resolves absolute path, doesn't supports jpath and other fancy things234 async fn resolve(&self, path: &Path) -> Result<SourcePath, Self::Error>;235236 /// Load resolved file237 /// This should only be called with value returned from [`ImportResolver::resolve_file`]/[`ImportResolver::resolve`],238 /// this cannot be resolved using associated type, as evaluator uses object instead of generic for [`ImportResolver`]239 async fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>, Self::Error>;240}241242#[derive(Trace)]243struct ResolvedImportResolver {244 resolved: RefCell<GcHashMap<(SourcePath, IStr), (SourcePath, bool)>>,245}246impl ImportResolver for ResolvedImportResolver {247 fn load_file_contents(&self, _resolved: &SourcePath) -> crate::Result<Vec<u8>> {248 unreachable!("all files should be loaded at this point");249 }250251 fn resolve_from(&self, from: &SourcePath, path: &str) -> crate::Result<SourcePath> {252 Ok(self253 .resolved254 .borrow()255 .get(&(from.clone(), path.into()))256 .expect("all imports should be resolved at this point")257 .0258 .clone())259 }260261 fn resolve_from_default(&self, path: &str) -> crate::Result<SourcePath> {262 self.resolve_from(&SourcePath::default(), path)263 }264265 fn resolve(&self, path: &Path) -> crate::Result<SourcePath> {266 bail!(crate::error::ErrorKind::AbsoluteImportNotSupported(267 path.to_owned()268 ))269 }270271 fn as_any(&self) -> &dyn std::any::Any {272 self273 }274}275276enum Job {277 LoadFile { path: SourcePath, parse: bool },278 ParseFile(SourcePath),279 ResolveImport { from: SourcePath, import: Import },280}281282#[allow(clippy::future_not_send)]283pub async fn async_import<H>(s: State, handler: H, path: impl AsRef<Path>) -> Result<(), H::Error>284where285 H: AsyncImportResolver,286{287 let mut resolved = s288 .import_resolver()289 .as_any()290 .downcast_ref::<ResolvedImportResolver>()291 .map_or_else(GcHashMap::new, |resolver| {292 std::mem::take(&mut *resolver.resolved.borrow_mut())293 });294 let mut queue = vec![Job::LoadFile {295 path: handler.resolve(path.as_ref()).await?,296 parse: true,297 }];298 while let Some(job) = queue.pop() {299 match job {300 Job::LoadFile { path, parse } => {301 if !s.0.file_cache.borrow().contains_key(&path) {302 let data = handler.load_file_contents(&path).await?;303 s.0.file_cache304 .borrow_mut()305 .insert(path.clone(), FileData::new_bytes(data.as_slice().into()));306 }307 if parse {308 queue.push(Job::ParseFile(path));309 }310 }311 Job::ParseFile(path) => {312 if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {313 if file.parsed.is_none() {314 let Some(code) = file.get_string() else {315 continue;316 };317 let source = Source::new(path.clone(), code.clone());318 // If failed - then skip import319 file.parsed =320 jrsonnet_parser::parse(&code, &ParserSettings { source }).ok();321 if let Some(parsed) = &file.parsed {322 let mut imports = FoundImports(vec![]);323 find_imports(parsed, &mut imports);324 for import in imports.0 {325 queue.push(Job::ResolveImport {326 from: path.clone(),327 import,328 });329 }330 }331 }332 }333 }334 Job::ResolveImport { from, import } => {335 if let Some((resolved, expression)) =336 resolved.get_mut(&(from.clone(), import.path.clone()))337 {338 if import.expression && !*expression {339 *expression = true;340 queue.push(Job::ParseFile(resolved.clone()));341 }342 continue;343 }344 let resolved = handler.resolve_from(&from, &import.path).await?;345 queue.push(Job::LoadFile {346 path: resolved,347 parse: import.expression,348 });349 }350 }351 }352 s.set_import_resolver(ResolvedImportResolver {353 resolved: RefCell::new(resolved),354 });355 Ok(())356}