difftreelog
feat allow both parsers at the same time
in: master
4 files changed
crates/jrsonnet-evaluator/Cargo.tomldiffbeforeafterboth--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -18,24 +18,26 @@
explaining-traces = ["annotate-snippets", "hi-doc"]
# Allows library authors to throw custom errors
anyhow-error = ["anyhow"]
-# Use hand-written recursive descent parser instead of PEG parser
+# Use hand-written recursive descent parser
ir-parser = ["dep:jrsonnet-ir-parser"]
+# Use PEG parser
+peg-parser = ["dep:jrsonnet-peg-parser"]
# Allows to preserve field order in objects
exp-preserve-order = []
# Implements field destructuring
-exp-destruct = ["jrsonnet-peg-parser/exp-destruct"]
+exp-destruct = ["jrsonnet-peg-parser?/exp-destruct", "jrsonnet-ir-parser?/exp-destruct"]
# Iteration over objects yields [key, value] elements
exp-object-iteration = []
# Bigint type
exp-bigint = ["num-bigint", "jrsonnet-types/exp-bigint"]
# obj?.field, obj?.['field']
-exp-null-coaelse = ["jrsonnet-peg-parser/exp-null-coaelse", "jrsonnet-ir-parser?/exp-null-coaelse"]
+exp-null-coaelse = ["jrsonnet-peg-parser?/exp-null-coaelse", "jrsonnet-ir-parser?/exp-null-coaelse"]
[dependencies]
jrsonnet-interner.workspace = true
jrsonnet-ir.workspace = true
-jrsonnet-peg-parser.workspace = true
+jrsonnet-peg-parser = { workspace = true, optional = true }
jrsonnet-ir-parser = { workspace = true, optional = true }
jrsonnet-types.workspace = true
jrsonnet-macros.workspace = true
crates/jrsonnet-evaluator/src/async_import.rsdiffbeforeafterboth1use 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};10#[cfg(feature = "ir-parser")]11use jrsonnet_ir_parser::ParserSettings;12#[cfg(not(feature = "ir-parser"))]13use jrsonnet_peg_parser::ParserSettings;14use rustc_hash::FxHashMap;1516use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, State};1718pub struct Import {19 path: ResolvePathOwned,20 expression: bool,21}2223pub struct FoundImports(Vec<Import>);2425// Visits all nodes, trying to find import statements26#[allow(clippy::too_many_lines)]27pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {28 #[allow(unused_variables, clippy::needless_pass_by_ref_mut)]29 fn in_destruct(dest: &Destruct, out: &mut FoundImports) {30 match dest {31 #[cfg(feature = "exp-destruct")]32 Destruct::Array {33 start,34 rest: _,35 end,36 } => {37 for dest in start {38 in_destruct(dest, out);39 }40 for dest in end {41 in_destruct(dest, out);42 }43 }44 #[cfg(feature = "exp-destruct")]45 Destruct::Object { fields, rest: _ } => {46 for (_, dest, default) in fields {47 if let Some(dest) = dest {48 in_destruct(dest, out);49 }50 if let Some(expr) = default {51 find_imports(expr, out);52 }53 }54 }55 #[cfg(feature = "exp-destruct")]56 Destruct::Skip => {}57 Destruct::Full(_) => {}58 }59 }60 fn in_compspec(specs: &[CompSpec], out: &mut FoundImports) {61 for spec in specs {62 match spec {63 CompSpec::IfSpec(IfSpecData(expr)) => find_imports(expr, out),64 CompSpec::ForSpec(ForSpecData(destruct, expr)) => {65 in_destruct(destruct, out);66 find_imports(expr, out);67 }68 }69 }70 }71 fn in_params(params: &ExprParams, out: &mut FoundImports) {72 for ExprParam { destruct, default } in &*params.exprs {73 in_destruct(destruct, out);74 if let Some(expr) = default {75 find_imports(expr, out);76 }77 }78 }79 fn in_bind(specs: &[BindSpec], out: &mut FoundImports) {80 for spec in specs {81 match spec {82 BindSpec::Field {83 into: dest,84 value: expr,85 } => {86 in_destruct(dest, out);87 find_imports(expr, out);88 }89 BindSpec::Function {90 name: _,91 params,92 value: expr,93 } => {94 in_params(params, out);95 find_imports(expr, out);96 }97 }98 }99 }100 fn in_args(ArgsDesc { unnamed, named }: &ArgsDesc, out: &mut FoundImports) {101 for expr in unnamed {102 find_imports(expr, out);103 }104 for (_, expr) in named {105 find_imports(expr, out);106 }107 }108 fn in_obj(obj: &ObjBody, out: &mut FoundImports) {109 match obj {110 ObjBody::MemberList(obj) => {111 for FieldMember {112 name,113 params,114 value,115 ..116 } in &obj.fields117 {118 match name {119 FieldName::Fixed(_) => {}120 FieldName::Dyn(expr) => find_imports(expr, out),121 }122 if let Some(params) = params {123 in_params(params, out);124 }125 find_imports(value, out);126 }127 for _ in &*obj.locals {128 todo!()129 }130 for assert in &*obj.asserts {131 find_imports(&assert.0, out);132 if let Some(expr) = &assert.1 {133 find_imports(expr, out);134 }135 }136 }137 ObjBody::ObjComp(_) => todo!(),138 }139 }140 match &**expr {141 Expr::Import(_, v) => {142 if let Expr::Str(s) = &***v {143 out.0.push(Import {144 path: ResolvePathOwned::Str(s.to_string()),145 expression: todo!(),146 });147 }148 // Non-string import will fail in runtime149 }150151 Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}152153 Expr::Arr(arr) => {154 for expr in &**arr {155 find_imports(expr, out);156 }157 }158 Expr::ArrComp(expr, specs) => {159 find_imports(expr, out);160 in_compspec(specs, out);161 }162 Expr::Obj(obj) => in_obj(obj, out),163 Expr::ObjExtend(expr, obj) => {164 find_imports(expr, out);165 in_obj(obj, out);166 }167 Expr::BinaryOp(binop) => {168 find_imports(&binop.lhs, out);169 find_imports(&binop.rhs, out);170 }171 Expr::AssertExpr(assert) => {172 let AssertExpr {173 assert: AssertStmt(expr, expr2),174 rest,175 } = &**assert;176 find_imports(expr, out);177 if let Some(expr) = expr2 {178 find_imports(expr, out);179 }180 find_imports(rest, out);181 }182 Expr::LocalExpr(specs, expr) => {183 in_bind(specs, out);184 find_imports(expr, out);185 }186 Expr::Apply(expr, args, _) => {187 find_imports(expr, out);188 in_args(args, out);189 }190 Expr::Index { indexable, parts } => {191 find_imports(indexable, out);192 for part in parts {193 find_imports(&part.value, out);194 }195 }196 Expr::Function(params, expr) => {197 in_params(params, out);198 find_imports(expr, out);199 }200 Expr::IfElse(if_else) => {201 let IfElse {202 cond: IfSpecData(expr),203 cond_then,204 cond_else,205 } = &**if_else;206 find_imports(expr, out);207 find_imports(cond_then, out);208 if let Some(expr) = cond_else {209 find_imports(expr, out);210 }211 }212 Expr::Slice(slice) => {213 let Slice {214 value,215 slice: SliceDesc { start, end, step },216 } = &**slice;217 find_imports(value, out);218 if let Some(expr) = start {219 find_imports(expr, out);220 }221 if let Some(expr) = end {222 find_imports(expr, out);223 }224 if let Some(expr) = step {225 find_imports(expr, out);226 }227 }228 Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {229 find_imports(expr, out);230 }231 }232}233234pub trait AsyncImportResolver {235 type Error;236 /// Resolves file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond237 /// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`238 /// where `${vendor}` is a library path.239 ///240 /// `from` should only be returned from [`ImportResolver::resolve`],241 /// or from other defined file, any other value may result in panic242 fn resolve_from(243 &self,244 from: &SourcePath,245 path: &dyn AsPathLike,246 ) -> impl Future<Output = Result<SourcePath, Self::Error>>;247 fn resolve_from_default(248 &self,249 path: &dyn AsPathLike,250 ) -> impl Future<Output = Result<SourcePath, Self::Error>> {251 async { self.resolve_from(&SourcePath::default(), path).await }252 }253254 /// Load resolved file255 /// This should only be called with value returned256 /// from [`ImportResolver::resolve_file`]/[`ImportResolver::resolve`],257 /// this cannot be resolved using associated type,258 /// as the evaluator uses object instead of generic for [`ImportResolver`]259 fn load_file_contents(260 &self,261 resolved: &SourcePath,262 ) -> impl Future<Output = Result<Vec<u8>, Self::Error>>;263}264265#[derive(Acyclic)]266struct ResolvedImportResolver {267 resolved: RefCell<FxHashMap<(SourcePath, ResolvePathOwned), (SourcePath, bool)>>,268}269impl ImportResolver for ResolvedImportResolver {270 fn load_file_contents(&self, _resolved: &SourcePath) -> crate::Result<Vec<u8>> {271 unreachable!("all files should be loaded at this point");272 }273274 fn resolve_from(&self, from: &SourcePath, path: &dyn AsPathLike) -> crate::Result<SourcePath> {275 Ok(self276 .resolved277 .borrow()278 .get(&(from.clone(), path.as_path().to_owned()))279 .expect("all imports should be resolved at this point")280 .0281 .clone())282 }283284 fn resolve_from_default(&self, path: &dyn AsPathLike) -> crate::Result<SourcePath> {285 self.resolve_from(&SourcePath::default(), path)286 }287}288289enum Job {290 LoadFile { path: SourcePath, parse: bool },291 ParseFile(SourcePath),292 ResolveImport { from: SourcePath, import: Import },293}294295#[allow(clippy::future_not_send)]296pub async fn async_import<H>(s: State, handler: H, path: &dyn AsPathLike) -> Result<(), H::Error>297where298 H: AsyncImportResolver,299{300 let resolved = (s.import_resolver() as &dyn Any)301 .downcast_ref::<ResolvedImportResolver>()302 .expect("for async imports, import_resolver should be set to ResolvedImportResolver");303304 let mut queue = vec![Job::LoadFile {305 path: handler.resolve_from_default(path).await?,306 parse: true,307 }];308 while let Some(job) = queue.pop() {309 match job {310 Job::LoadFile { path, parse } => {311 if !s.0.file_cache.borrow().contains_key(&path) {312 let data = handler.load_file_contents(&path).await?;313 s.0.file_cache314 .borrow_mut()315 .insert(path.clone(), FileData::new_bytes(data.as_slice().into()));316 }317 if parse {318 queue.push(Job::ParseFile(path));319 }320 }321 Job::ParseFile(path) => {322 if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {323 if file.parsed.is_none() {324 let Some(code) = file.get_string() else {325 continue;326 };327 let source = Source::new(path.clone(), code.clone());328 // If failed - then skip import329 file.parsed = crate::parse_jsonnet(&code, &ParserSettings { source })330 .map(Rc::new)331 .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 {347 let mut resolved_map = resolved.resolved.borrow_mut();348 if let Some((resolved, expression)) =349 resolved_map.get_mut(&(from.clone(), import.path.clone()))350 {351 if import.expression && !*expression {352 *expression = true;353 queue.push(Job::ParseFile(resolved.clone()));354 }355 continue;356 }357 }358 let resolved = handler.resolve_from(&from, &import.path).await?;359 queue.push(Job::LoadFile {360 path: resolved,361 parse: import.expression,362 });363 }364 }365 }366 Ok(())367}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}crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -14,6 +14,22 @@
ObjValue, ResolvePathOwned,
};
+#[derive(Debug, Clone)]
+pub struct SyntaxErrorLocation {
+ pub offset: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct SyntaxError {
+ pub message: String,
+ pub location: SyntaxErrorLocation,
+}
+impl fmt::Display for SyntaxError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}", self.message)
+ }
+}
+
pub(crate) fn format_found(list: &[IStr], what: &str) -> String {
if list.is_empty() {
return String::new();
@@ -154,31 +170,11 @@
ImportNotSupported(SourcePath, ResolvePathOwned),
#[error("can't import from virtual file")]
CantImportFromVirtualFile,
- #[cfg(not(feature = "ir-parser"))]
- #[error(
- "syntax error: {}",
- // Peg has no fancier way to handle critical parsing errors https://github.com/kevinmehall/rust-peg/issues/225
- {.error.expected.tokens().find(|t| t.starts_with("!!!")).map_or_else(|| {
- format!(
- "expected {}, got {:?}",
- .error.expected,
- .path.code().chars().nth(error.location.offset)
- .map_or_else(|| "EOF".into(), |c| c.to_string())
- )
- }, |v| v[3..].into())}
- )]
- ImportSyntaxError {
- path: Source,
- #[trace(skip)]
- error: Box<jrsonnet_peg_parser::ParseError>,
- },
-
- #[cfg(feature = "ir-parser")]
#[error("syntax error: {error}")]
ImportSyntaxError {
path: Source,
#[trace(skip)]
- error: Box<jrsonnet_ir_parser::ParseError>,
+ error: Box<SyntaxError>,
},
#[error("runtime error: {}", format_empty_str(.0))]
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -46,10 +46,11 @@
use jrsonnet_ir::{Expr, Source, SourcePath};
#[doc(hidden)]
pub use jrsonnet_macros;
-#[cfg(feature = "ir-parser")]
-use jrsonnet_ir_parser::ParserSettings;
-#[cfg(not(feature = "ir-parser"))]
-use jrsonnet_peg_parser::ParserSettings;
+
+#[cfg(not(any(feature = "ir-parser", feature = "peg-parser")))]
+compile_error!("at least one of `ir-parser` or `peg-parser` features must be enabled");
+
+pub use error::{SyntaxError, SyntaxErrorLocation};
pub use obj::*;
pub use rustc_hash;
use rustc_hash::FxHashMap;
@@ -59,20 +60,64 @@
use crate::gc::WithCapacityExt as _;
+pub(crate) fn parse_jsonnet(code: &str, source: Source) -> Result<Expr, SyntaxError> {
+ #[cfg(all(feature = "ir-parser", feature = "peg-parser"))]
+ {
+ if std::env::var_os("JRSONNET_LEGACY_PARSER").is_some() {
+ return parse_peg(code, source);
+ }
+ return parse_ir(code, source);
+ }
+ #[cfg(all(feature = "ir-parser", not(feature = "peg-parser")))]
+ {
+ return parse_ir(code, source);
+ }
+ #[cfg(all(feature = "peg-parser", not(feature = "ir-parser")))]
+ {
+ return parse_peg(code, source);
+ }
+}
+
#[cfg(feature = "ir-parser")]
-pub(crate) fn parse_jsonnet(
- code: &str,
- settings: &ParserSettings,
-) -> Result<Expr, jrsonnet_ir_parser::ParseError> {
- jrsonnet_ir_parser::parse(code, settings)
+fn parse_ir(code: &str, source: Source) -> Result<Expr, SyntaxError> {
+ jrsonnet_ir_parser::parse(code, &jrsonnet_ir_parser::ParserSettings { source }).map_err(
+ |e| SyntaxError {
+ message: e.message,
+ location: SyntaxErrorLocation {
+ offset: e.location.offset,
+ },
+ },
+ )
}
-#[cfg(not(feature = "ir-parser"))]
-pub(crate) fn parse_jsonnet(
- code: &str,
- settings: &ParserSettings,
-) -> Result<Expr, jrsonnet_peg_parser::ParseError> {
- jrsonnet_peg_parser::parse(code, settings)
+#[cfg(feature = "peg-parser")]
+fn parse_peg(code: &str, source: Source) -> Result<Expr, SyntaxError> {
+ jrsonnet_peg_parser::parse(code, &jrsonnet_peg_parser::ParserSettings { source }).map_err(
+ |e| {
+ let message = e
+ .expected
+ .tokens()
+ .find(|t| t.starts_with("!!!"))
+ .map_or_else(
+ || {
+ format!(
+ "expected {}, got {:?}",
+ e.expected,
+ code.chars()
+ .nth(e.location.offset)
+ .map_or_else(|| "EOF".into(), |c: char| c.to_string())
+ )
+ },
+ |v| v[3..].into(),
+ );
+ SyntaxError {
+ message,
+ location: SyntaxErrorLocation {
+ offset: e.location.offset,
+ },
+ }
+ },
+ )
}
cc_dyn!(
@@ -364,12 +409,7 @@
let file_name = Source::new(path.clone(), code.clone());
if file.parsed.is_none() {
file.parsed = Some(
- parse_jsonnet(
- &code,
- &ParserSettings {
- source: file_name.clone(),
- },
- )
+ parse_jsonnet(&code, file_name.clone())
.map(Rc::new)
.map_err(|e| ImportSyntaxError {
path: file_name.clone(),
@@ -480,12 +520,7 @@
pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {
let code = code.into();
let source = Source::new_virtual(name.into(), code.clone());
- let parsed = parse_jsonnet(
- &code,
- &ParserSettings {
- source: source.clone(),
- },
- )
+ let parsed = parse_jsonnet(&code, source.clone())
.map_err(|e| ImportSyntaxError {
path: source.clone(),
error: Box::new(e),
@@ -501,12 +536,7 @@
) -> Result<Val> {
let code = code.into();
let source = Source::new_virtual(name.into(), code.clone());
- let parsed = parse_jsonnet(
- &code,
- &ParserSettings {
- source: source.clone(),
- },
- )
+ let parsed = parse_jsonnet(&code, source.clone())
.map_err(|e| ImportSyntaxError {
path: source.clone(),
error: Box::new(e),