difftreelog
refactor only keep used spans in IR
in: master
12 files changed
Cargo.lockdiffbeforeafterboth--- a/Cargo.lock
+++ b/Cargo.lock
@@ -730,6 +730,7 @@
version = "0.5.0-pre97"
dependencies = [
"insta",
+ "jrsonnet-gcmodule",
"jrsonnet-ir",
"peg",
]
crates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -38,7 +38,7 @@
Self::new(RangeArray::empty())
}
- pub fn expr(ctx: Context, exprs: Rc<Vec<Spanned<Expr>>>) -> Self {
+ pub fn expr(ctx: Context, exprs: Rc<Vec<Expr>>) -> Self {
Self::new(ExprArray::new(ctx, exprs))
}
crates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -118,11 +118,11 @@
#[derive(Debug, Trace, Clone)]
pub struct ExprArray {
ctx: Context,
- src: Rc<Vec<Spanned<Expr>>>,
+ src: Rc<Vec<Expr>>,
cached: Cc<RefCell<Vec<ArrayThunk>>>,
}
impl ExprArray {
- pub fn new(ctx: Context, src: Rc<Vec<Spanned<Expr>>>) -> Self {
+ pub fn new(ctx: Context, src: Rc<Vec<Expr>>) -> Self {
Self {
ctx,
cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),
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};10use jrsonnet_peg_parser::ParserSettings;11use rustc_hash::FxHashMap;1213use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, State};1415pub struct Import {16 path: ResolvePathOwned,17 expression: bool,18}1920pub struct FoundImports(Vec<Import>);2122// Visits all nodes, trying to find import statements23#[allow(clippy::too_many_lines)]24pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {25 #[allow(unused_variables, clippy::needless_pass_by_ref_mut)]26 fn in_destruct(dest: &Destruct, out: &mut FoundImports) {27 match dest {28 #[cfg(feature = "exp-destruct")]29 Destruct::Array {30 start,31 rest: _,32 end,33 } => {34 for dest in start {35 in_destruct(dest, out);36 }37 for dest in end {38 in_destruct(dest, out);39 }40 }41 #[cfg(feature = "exp-destruct")]42 Destruct::Object { fields, rest: _ } => {43 for (_, dest, default) in fields {44 if let Some(dest) = dest {45 in_destruct(dest, out);46 }47 if let Some(expr) = default {48 find_imports(expr, out);49 }50 }51 }52 #[cfg(feature = "exp-destruct")]53 Destruct::Skip => {}54 Destruct::Full(_) => {}55 }56 }57 fn in_compspec(specs: &[CompSpec], out: &mut FoundImports) {58 for spec in specs {59 match spec {60 CompSpec::IfSpec(IfSpecData(expr)) => find_imports(expr, out),61 CompSpec::ForSpec(ForSpecData(destruct, expr)) => {62 in_destruct(destruct, out);63 find_imports(expr, out);64 }65 }66 }67 }68 fn in_params(params: &ExprParams, out: &mut FoundImports) {69 for ExprParam { destruct, default } in &*params.exprs {70 in_destruct(destruct, out);71 if let Some(expr) = default {72 find_imports(expr, out);73 }74 }75 }76 fn in_bind(specs: &[BindSpec], out: &mut FoundImports) {77 for spec in specs {78 match spec {79 BindSpec::Field {80 into: dest,81 value: expr,82 } => {83 in_destruct(dest, out);84 find_imports(expr, out);85 }86 BindSpec::Function {87 name: _,88 params,89 value: expr,90 } => {91 in_params(params, out);92 find_imports(expr, out);93 }94 }95 }96 }97 fn in_args(ArgsDesc { unnamed, named }: &ArgsDesc, out: &mut FoundImports) {98 for expr in unnamed {99 find_imports(expr, out);100 }101 for (_, expr) in named {102 find_imports(expr, out);103 }104 }105 fn in_obj(obj: &ObjBody, out: &mut FoundImports) {106 match obj {107 ObjBody::MemberList(obj) => {108 for FieldMember {109 name,110 params,111 value,112 ..113 } in &obj.fields114 {115 match name {116 FieldName::Fixed(_) => {}117 FieldName::Dyn(expr) => find_imports(expr, out),118 }119 if let Some(params) = params {120 in_params(params, out);121 }122 find_imports(value, out);123 }124 for _ in &*obj.locals {125 todo!()126 }127 for assert in &*obj.asserts {128 find_imports(&assert.0, out);129 if let Some(expr) = &assert.1 {130 find_imports(expr, out);131 }132 }133 }134 ObjBody::ObjComp(_) => todo!(),135 }136 }137 match &**expr {138 Expr::Import(_, v) => {139 if let Expr::Str(s) = &***v {140 out.0.push(Import {141 path: ResolvePathOwned::Str(s.to_string()),142 expression: matches!(&**expr, Expr::Import(ImportKind::Normal, _)),143 });144 }145 // Non-string import will fail in runtime146 }147148 Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}149150 Expr::Arr(arr) => {151 for expr in &**arr {152 find_imports(expr, out);153 }154 }155 Expr::ArrComp(expr, specs) => {156 find_imports(expr, out);157 in_compspec(specs, out);158 }159 Expr::Obj(obj) => in_obj(obj, out),160 Expr::ObjExtend(expr, obj) => {161 find_imports(expr, out);162 in_obj(obj, out);163 }164 Expr::BinaryOp(binop) => {165 find_imports(&binop.lhs, out);166 find_imports(&binop.rhs, out);167 }168 Expr::AssertExpr(assert) => {169 let AssertExpr {170 assert: AssertStmt(expr, expr2),171 rest,172 } = &**assert;173 find_imports(expr, out);174 if let Some(expr) = expr2 {175 find_imports(expr, out);176 }177 find_imports(rest, out);178 }179 Expr::LocalExpr(specs, expr) => {180 in_bind(specs, out);181 find_imports(expr, out);182 }183 Expr::Apply(expr, args, _) => {184 find_imports(expr, out);185 in_args(args, out);186 }187 Expr::Index { indexable, parts } => {188 find_imports(indexable, out);189 for part in parts {190 find_imports(&part.value, out);191 }192 }193 Expr::Function(params, expr) => {194 in_params(params, out);195 find_imports(expr, out);196 }197 Expr::IfElse(if_else) => {198 let IfElse {199 cond: IfSpecData(expr),200 cond_then,201 cond_else,202 } = &**if_else;203 find_imports(expr, out);204 find_imports(cond_then, out);205 if let Some(expr) = cond_else {206 find_imports(expr, out);207 }208 }209 Expr::Slice(slice) => {210 let Slice {211 value,212 slice: SliceDesc { start, end, step },213 } = &**slice;214 find_imports(value, out);215 if let Some(expr) = start {216 find_imports(expr, out);217 }218 if let Some(expr) = end {219 find_imports(expr, out);220 }221 if let Some(expr) = step {222 find_imports(expr, out);223 }224 }225 Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {226 find_imports(expr, out);227 }228 }229}230231pub trait AsyncImportResolver {232 type Error;233 /// Resolves file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond234 /// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`235 /// where `${vendor}` is a library path.236 ///237 /// `from` should only be returned from [`ImportResolver::resolve`],238 /// or from other defined file, any other value may result in panic239 fn resolve_from(240 &self,241 from: &SourcePath,242 path: &dyn AsPathLike,243 ) -> impl Future<Output = Result<SourcePath, Self::Error>>;244 fn resolve_from_default(245 &self,246 path: &dyn AsPathLike,247 ) -> impl Future<Output = Result<SourcePath, Self::Error>> {248 async { self.resolve_from(&SourcePath::default(), path).await }249 }250251 /// Load resolved file252 /// This should only be called with value returned253 /// from [`ImportResolver::resolve_file`]/[`ImportResolver::resolve`],254 /// this cannot be resolved using associated type,255 /// as the evaluator uses object instead of generic for [`ImportResolver`]256 fn load_file_contents(257 &self,258 resolved: &SourcePath,259 ) -> impl Future<Output = Result<Vec<u8>, Self::Error>>;260}261262#[derive(Acyclic)]263struct ResolvedImportResolver {264 resolved: RefCell<FxHashMap<(SourcePath, ResolvePathOwned), (SourcePath, bool)>>,265}266impl ImportResolver for ResolvedImportResolver {267 fn load_file_contents(&self, _resolved: &SourcePath) -> crate::Result<Vec<u8>> {268 unreachable!("all files should be loaded at this point");269 }270271 fn resolve_from(&self, from: &SourcePath, path: &dyn AsPathLike) -> crate::Result<SourcePath> {272 Ok(self273 .resolved274 .borrow()275 .get(&(from.clone(), path.as_path().to_owned()))276 .expect("all imports should be resolved at this point")277 .0278 .clone())279 }280281 fn resolve_from_default(&self, path: &dyn AsPathLike) -> crate::Result<SourcePath> {282 self.resolve_from(&SourcePath::default(), path)283 }284}285286enum Job {287 LoadFile { path: SourcePath, parse: bool },288 ParseFile(SourcePath),289 ResolveImport { from: SourcePath, import: Import },290}291292#[allow(clippy::future_not_send)]293pub async fn async_import<H>(s: State, handler: H, path: &dyn AsPathLike) -> Result<(), H::Error>294where295 H: AsyncImportResolver,296{297 let resolved = (s.import_resolver() as &dyn Any)298 .downcast_ref::<ResolvedImportResolver>()299 .expect("for async imports, import_resolver should be set to ResolvedImportResolver");300301 let mut queue = vec![Job::LoadFile {302 path: handler.resolve_from_default(path).await?,303 parse: true,304 }];305 while let Some(job) = queue.pop() {306 match job {307 Job::LoadFile { path, parse } => {308 if !s.0.file_cache.borrow().contains_key(&path) {309 let data = handler.load_file_contents(&path).await?;310 s.0.file_cache311 .borrow_mut()312 .insert(path.clone(), FileData::new_bytes(data.as_slice().into()));313 }314 if parse {315 queue.push(Job::ParseFile(path));316 }317 }318 Job::ParseFile(path) => {319 if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {320 if file.parsed.is_none() {321 let Some(code) = file.get_string() else {322 continue;323 };324 let source = Source::new(path.clone(), code.clone());325 // If failed - then skip import326 file.parsed = jrsonnet_peg_parser::parse(&code, &ParserSettings { source })327 .map(Rc::new)328 .ok();329 if let Some(parsed) = &file.parsed {330 let mut imports = FoundImports(vec![]);331 find_imports(parsed, &mut imports);332 for import in imports.0 {333 queue.push(Job::ResolveImport {334 from: path.clone(),335 import,336 });337 }338 }339 }340 }341 }342 Job::ResolveImport { from, import } => {343 {344 let mut resolved_map = resolved.resolved.borrow_mut();345 if let Some((resolved, expression)) =346 resolved_map.get_mut(&(from.clone(), import.path.clone()))347 {348 if import.expression && !*expression {349 *expression = true;350 queue.push(Job::ParseFile(resolved.clone()));351 }352 continue;353 }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 Ok(())364}crates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -53,7 +53,7 @@
Expr::Str(_)
| Expr::Num(_)
| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,
- Expr::Arr(a) => a.iter().all(|e| is_trivial(&**e)),
+ Expr::Arr(a) => a.iter().all(|e| is_trivial(&*e)),
_ => false,
}
}
@@ -71,7 +71,7 @@
}
Val::Arr(ArrValue::eager(
n.iter()
- .map(|e| evaluate_trivial(&**e))
+ .map(|e| evaluate_trivial(&*e))
.map(|e| e.expect("checked trivial"))
.collect(),
))
@@ -80,12 +80,7 @@
})
}
-pub fn evaluate_method(
- ctx: Context,
- name: IStr,
- params: ExprParams,
- body: Rc<Spanned<Expr>>,
-) -> Val {
+pub fn evaluate_method(ctx: Context, name: IStr, params: ExprParams, body: Rc<Expr>) -> Val {
Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
name,
ctx,
@@ -97,18 +92,21 @@
pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {
Ok(match field_name {
FieldName::Fixed(n) => Some(n.clone()),
- FieldName::Dyn(expr) => in_frame(
- CallLocation::new(&expr.span()),
- || "evaluating field name".to_string(),
- || {
- let value = evaluate(ctx, expr)?;
- if matches!(value, Val::Null) {
- Ok(None)
- } else {
- Ok(Some(IStr::from_untyped(value)?))
- }
- },
- )?,
+ FieldName::Dyn(expr) => {
+ // FIXME: Span
+ let value = evaluate(ctx, expr)?;
+ if matches!(value, Val::Null) {
+ None
+ } else {
+ Some(IStr::from_untyped(value)?)
+ }
+ } //
+ // in_frame(
+ // CallLocation::new(&expr.span()),
+ // || "evaluating field name".to_string(),
+ // || {
+ // },
+ // )?,
})
}
@@ -119,46 +117,48 @@
) -> Result<()> {
match specs.first() {
None => callback(ctx)?,
- Some(CompSpec::IfSpec(IfSpecData(cond))) => {
+ Some(CompSpec::IfSpec(Spanned(IfSpecData(cond), _))) => {
if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {
evaluate_comp(ctx, &specs[1..], callback)?;
}
}
- Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {
- Val::Arr(list) => {
- for item in list.iter_lazy() {
- let fctx = Pending::new();
- let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
- destruct(var, item, fctx.clone(), &mut new_bindings)?;
- let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
+ Some(CompSpec::ForSpec(Spanned(ForSpecData(var, expr), _))) => {
+ match evaluate(ctx.clone(), expr)? {
+ Val::Arr(list) => {
+ for item in list.iter_lazy() {
+ let fctx = Pending::new();
+ let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
+ destruct(var, item, fctx.clone(), &mut new_bindings)?;
+ let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
- evaluate_comp(ctx, &specs[1..], callback)?;
+ evaluate_comp(ctx, &specs[1..], callback)?;
+ }
}
- }
- #[cfg(feature = "exp-object-iteration")]
- Val::Obj(obj) => {
- for field in obj.fields(
- // TODO: Should there be ability to preserve iteration order?
- #[cfg(feature = "exp-preserve-order")]
- false,
- ) {
- let fctx = Pending::new();
- let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
- let obj = obj.clone();
- let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![
- Thunk::evaluated(Val::string(field.clone())),
- Thunk!(move || obj.get(field).transpose().expect(
- "field exists, as field name was obtained from object.fields()",
- )),
- ])));
- destruct(var, value, fctx.clone(), &mut new_bindings)?;
- let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
+ #[cfg(feature = "exp-object-iteration")]
+ Val::Obj(obj) => {
+ for field in obj.fields(
+ // TODO: Should there be ability to preserve iteration order?
+ #[cfg(feature = "exp-preserve-order")]
+ false,
+ ) {
+ let fctx = Pending::new();
+ let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
+ let obj = obj.clone();
+ let value = Thunk::evaluated(Val::Arr(ArrValue::lazy(vec![
+ Thunk::evaluated(Val::string(field.clone())),
+ Thunk!(move || obj.get(field).transpose().expect(
+ "field exists, as field name was obtained from object.fields()",
+ )),
+ ])));
+ destruct(var, value, fctx.clone(), &mut new_bindings)?;
+ let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
- evaluate_comp(ctx, &specs[1..], callback)?;
+ evaluate_comp(ctx, &specs[1..], callback)?;
+ }
}
+ _ => bail!(InComprehensionCanOnlyIterateOverArray),
}
- _ => bail!(InComprehensionCanOnlyIterateOverArray),
- },
+ }
}
Ok(())
}
@@ -221,7 +221,7 @@
#[derive(Trace)]
struct UnboundValue<B: Trace> {
uctx: B,
- value: Rc<Spanned<Expr>>,
+ value: Rc<Expr>,
name: IStr,
}
impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {
@@ -235,7 +235,8 @@
.field(name.clone())
.with_add(*plus)
.with_visibility(*visibility)
- .with_location(value.span())
+ // FIXME
+ // .with_location(value.span())
.bindable(UnboundValue {
uctx,
value: value.clone(),
@@ -251,7 +252,7 @@
#[derive(Trace)]
struct UnboundMethod<B: Trace> {
uctx: B,
- value: Rc<Spanned<Expr>>,
+ value: Rc<Expr>,
params: ExprParams,
name: IStr,
}
@@ -270,7 +271,7 @@
builder
.field(name.clone())
.with_visibility(*visibility)
- .with_location(value.span())
+ // .with_location(value.span())
.bindable(UnboundMethod {
uctx,
value: value.clone(),
@@ -337,7 +338,7 @@
pub fn evaluate_apply(
ctx: Context,
- value: &Spanned<Expr>,
+ value: &Expr,
args: &ArgsDesc,
loc: CallLocation<'_>,
tailstrict: bool,
@@ -379,16 +380,16 @@
Ok(())
}
-pub fn evaluate_named_param(ctx: Context, expr: &Spanned<Expr>, name: ParamName) -> Result<Val> {
+pub fn evaluate_named_param(ctx: Context, expr: &Expr, name: ParamName) -> Result<Val> {
match name {
ParamName::Named(name) => evaluate_named(ctx, expr, name),
ParamName::Unnamed => evaluate(ctx, expr),
}
}
-pub fn evaluate_named(ctx: Context, expr: &Spanned<Expr>, name: IStr) -> Result<Val> {
+pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {
use Expr::*;
- Ok(match &**expr {
+ Ok(match &*expr {
Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),
_ => evaluate(ctx, expr)?,
})
@@ -417,7 +418,7 @@
// because the standalone super literal is not supported, that is because in other
// implementations `in super` treated differently from `in smth_else`.
BinaryOp(bin)
- if matches!(&*bin.rhs, Expr::Literal(LiteralType::Super))
+ if matches!(&bin.rhs, Expr::Literal(LiteralType::Super))
&& bin.op == BinaryOpType::In =>
{
let sup_this = ctx.try_sup_this()?;
@@ -433,12 +434,12 @@
UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
Var(name) => in_frame(
CallLocation::new(&name.span()),
- || format!("local <{name}> access"),
+ || format!("local <{}> access", &**name),
|| ctx.binding((**name).clone())?.evaluate(),
)?,
Index { indexable, parts } => ensure_sufficient_stack(|| {
let mut parts = parts.iter();
- let mut indexable = if matches!(&***indexable, Expr::Literal(LiteralType::Super)) {
+ let mut indexable = if matches!(&**indexable, Expr::Literal(LiteralType::Super)) {
let part = parts.next().expect("at least part should exist");
// sup_this existence check might also be skipped here for null-coalesce...
// But I believe this might cause errors.
@@ -463,7 +464,7 @@
let name = name.into_flat();
match sup_this
.get_super(name.clone())
- .with_description_src(&part.value, || format!("field <{name}> access"))?
+ .with_description_src(&part.span, || format!("field <{name}> access"))?
{
Some(v) => v,
#[cfg(feature = "exp-null-coaelse")]
@@ -485,7 +486,7 @@
indexable = match (indexable, evaluate(ctx.clone(), &part.value)?) {
(Val::Obj(v), Val::Str(key)) => match v
.get(key.clone().into_flat())
- .with_description_src(&part.value, || format!("field <{key}> access"))?
+ .with_description_src(&part.span, || format!("field <{key}> access"))?
{
Some(v) => v,
#[cfg(feature = "exp-null-coaelse")]
@@ -497,7 +498,7 @@
key.clone().into_flat(),
suggestions,
)))
- .with_description_src(&part.value, || format!("field <{key}> access"));
+ .with_description_src(&part.span, || format!("field <{key}> access"));
}
},
(Val::Obj(_), n) => bail!(ValueIndexMustBeTypeGot(
@@ -605,17 +606,21 @@
evaluate_assert(ctx.clone(), &assert.assert)?;
evaluate(ctx, &assert.rest)?
}
- ErrorStmt(e) => in_frame(
- CallLocation::new(&e.span()),
+ ErrorStmt(s, e) => in_frame(
+ CallLocation::new(&s),
|| "error statement".to_owned(),
|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
)?,
IfElse(if_else) => {
- if in_frame(
- CallLocation::new(&if_else.cond.0.span()),
- || "if condition".to_owned(),
- || bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?),
- )? {
+ if
+ // FIXME
+ //in_frame(
+ // CallLocation::new(&if_else.cond.0.span()),
+ // || "if condition".to_owned(),
+ // ||
+ bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?)?
+ // )?
+ {
evaluate(ctx, &if_else.cond_then)?
} else {
match &if_else.cond_else {
@@ -626,14 +631,13 @@
}
Slice(slice) => {
fn parse_idx<T: Typed + FromUntyped>(
- loc: CallLocation<'_>,
ctx: Context,
expr: Option<&Spanned<Expr>>,
desc: &'static str,
) -> Result<Option<T>> {
if let Some(value) = expr {
Ok(in_frame(
- loc,
+ CallLocation::new(&value.span()),
|| format!("slice {desc}"),
|| <Option<T>>::from_untyped(evaluate(ctx, value)?),
)?)
@@ -643,24 +647,23 @@
}
let indexable = evaluate(ctx.clone(), &slice.value)?;
- let loc = CallLocation::new(&loc);
- let start = parse_idx(loc, ctx.clone(), slice.slice.start.as_ref(), "start")?;
- let end = parse_idx(loc, ctx.clone(), slice.slice.end.as_ref(), "end")?;
- let step = parse_idx(loc, ctx, slice.slice.step.as_ref(), "step")?;
+ let start = parse_idx(ctx.clone(), slice.slice.start.as_ref(), "start")?;
+ let end = parse_idx(ctx.clone(), slice.slice.end.as_ref(), "end")?;
+ let step = parse_idx(ctx, slice.slice.step.as_ref(), "step")?;
IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?
}
Import(kind, path) => {
- let Expr::Str(path) = &***path else {
+ let Expr::Str(path) = &**path else {
bail!("computed imports are not supported")
};
- let tmp = loc.clone().0;
with_state(|s| {
- let resolved_path = s.resolve_from(tmp.source_path(), path)?;
- Ok(match kind {
+ let span = kind.span();
+ let resolved_path = s.resolve_from(span.0.source_path(), path)?;
+ Ok(match &**kind {
ImportKind::Normal => in_frame(
- CallLocation::new(&loc),
+ CallLocation::new(&span),
|| format!("import {:?}", path.clone()),
|| s.import_resolved(resolved_path),
)?,
crates/jrsonnet-evaluator/src/evaluate/operator.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/operator.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/operator.rs
@@ -147,9 +147,9 @@
pub fn evaluate_binary_op_special(
ctx: Context,
- a: &Spanned<Expr>,
+ a: &Expr,
op: BinaryOpType,
- b: &Spanned<Expr>,
+ b: &Expr,
) -> Result<Val> {
use BinaryOpType::*;
use Val::*;
crates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -3,8 +3,8 @@
use educe::Educe;
use jrsonnet_gcmodule::{Cc, Trace};
use jrsonnet_interner::IStr;
+use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};
pub use jrsonnet_macros::builtin;
-use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};
use self::{
builtin::{Builtin, StaticBuiltin},
@@ -71,7 +71,7 @@
/// Function parameter definition
pub params: ExprParams,
/// Function body
- pub body: Rc<Spanned<Expr>>,
+ pub body: Rc<Expr>,
}
impl FuncDesc {
/// Create body context, but fill arguments without defaults with lazy error
@@ -256,7 +256,7 @@
#[cfg(feature = "exp-destruct")]
_ => return false,
};
- **desc.body == Expr::Var(id.clone())
+ matches!(&*desc.body, Expr::Var(v) if &**v == id)
}
_ => false,
}
crates/jrsonnet-evaluator/src/function/parse.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -2,7 +2,7 @@
use jrsonnet_ir::{
function::{FunctionSignature, ParamName},
- ArgsDesc, Expr, ExprParams, Spanned,
+ ArgsDesc, Expr, ExprParams,
};
use rustc_hash::FxHashMap;
@@ -15,7 +15,7 @@
Context, Pending, Thunk, Val,
};
-fn eval_arg(ctx: Context, arg: &Rc<Spanned<Expr>>, tailstrict: bool) -> Result<Thunk<Val>> {
+fn eval_arg(ctx: Context, arg: &Rc<Expr>, tailstrict: bool) -> Result<Thunk<Val>> {
if tailstrict {
Ok(Thunk::evaluated(evaluate(ctx, arg)?))
} else {
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -5,7 +5,7 @@
extern crate self as jrsonnet_evaluator;
mod arr;
-pub mod async_import;
+// pub mod async_import;
mod ctx;
mod dynamic;
pub mod error;
@@ -187,7 +187,7 @@
struct FileData {
string: Option<IStr>,
bytes: Option<IBytes>,
- parsed: Option<Rc<Spanned<Expr>>>,
+ parsed: Option<Rc<Expr>>,
evaluated: Option<Val>,
evaluating: bool,
crates/jrsonnet-ir/src/expr.rsdiffbeforeafterboth--- a/crates/jrsonnet-ir/src/expr.rs
+++ b/crates/jrsonnet-ir/src/expr.rs
@@ -17,7 +17,7 @@
/// {fixed: 2}
Fixed(IStr),
/// {["dyn"+"amic"]: 3}
- Dyn(Spanned<Expr>),
+ Dyn(Expr),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]
@@ -46,7 +46,7 @@
pub plus: bool,
pub params: Option<ExprParams>,
pub visibility: Visibility,
- pub value: Rc<Spanned<Expr>>,
+ pub value: Rc<Expr>,
}
#[derive(Debug, PartialEq, Acyclic)]
@@ -152,7 +152,7 @@
#[derive(Debug, PartialEq, Acyclic)]
pub struct ExprParam {
pub destruct: Destruct,
- pub default: Option<Rc<Spanned<Expr>>>,
+ pub default: Option<Rc<Expr>>,
}
/// Defined function parameters
@@ -194,11 +194,11 @@
#[derive(Debug, PartialEq, Acyclic)]
pub struct ArgsDesc {
- pub unnamed: Vec<Rc<Spanned<Expr>>>,
- pub named: Vec<(IStr, Rc<Spanned<Expr>>)>,
+ pub unnamed: Vec<Rc<Expr>>,
+ pub named: Vec<(IStr, Rc<Expr>)>,
}
impl ArgsDesc {
- pub fn new(unnamed: Vec<Rc<Spanned<Expr>>>, named: Vec<(IStr, Rc<Spanned<Expr>>)>) -> Self {
+ pub fn new(unnamed: Vec<Rc<Expr>>, named: Vec<(IStr, Rc<Expr>)>) -> Self {
Self { unnamed, named }
}
}
@@ -277,12 +277,12 @@
pub enum BindSpec {
Field {
into: Destruct,
- value: Rc<Spanned<Expr>>,
+ value: Rc<Expr>,
},
Function {
name: IStr,
params: ExprParams,
- value: Rc<Spanned<Expr>>,
+ value: Rc<Expr>,
},
}
impl BindSpec {
@@ -295,15 +295,15 @@
}
#[derive(Debug, PartialEq, Acyclic)]
-pub struct IfSpecData(pub Spanned<Expr>);
+pub struct IfSpecData(pub Expr);
#[derive(Debug, PartialEq, Acyclic)]
-pub struct ForSpecData(pub Destruct, pub Spanned<Expr>);
+pub struct ForSpecData(pub Destruct, pub Expr);
#[derive(Debug, PartialEq, Acyclic)]
pub enum CompSpec {
- IfSpec(IfSpecData),
- ForSpec(ForSpecData),
+ IfSpec(Spanned<IfSpecData>),
+ ForSpec(Spanned<ForSpecData>),
}
#[derive(Debug, PartialEq, Acyclic)]
@@ -346,14 +346,14 @@
#[derive(Debug, PartialEq, Acyclic)]
pub struct AssertExpr {
pub assert: AssertStmt,
- pub rest: Spanned<Expr>,
+ pub rest: Expr,
}
#[derive(Debug, PartialEq, Acyclic)]
pub struct BinaryOp {
- pub lhs: Spanned<Expr>,
+ pub lhs: Expr,
pub op: BinaryOpType,
- pub rhs: Spanned<Expr>,
+ pub rhs: Expr,
}
#[derive(Debug, PartialEq, Acyclic)]
@@ -366,13 +366,13 @@
#[derive(Debug, PartialEq, Acyclic)]
pub struct IfElse {
pub cond: IfSpecData,
- pub cond_then: Spanned<Expr>,
- pub cond_else: Option<Spanned<Expr>>,
+ pub cond_then: Expr,
+ pub cond_else: Option<Expr>,
}
#[derive(Debug, PartialEq, Acyclic)]
pub struct Slice {
- pub value: Spanned<Expr>,
+ pub value: Expr,
pub slice: SliceDesc,
}
@@ -389,7 +389,7 @@
Var(Spanned<IStr>),
/// Array of expressions: [1, 2, "Hello"]
- Arr(Rc<Vec<Spanned<Expr>>>),
+ Arr(Rc<Vec<Expr>>),
/// Array comprehension:
/// ```jsonnet
/// ingredients: [
@@ -401,35 +401,35 @@
/// ]
/// ],
/// ```
- ArrComp(Rc<Spanned<Expr>>, Vec<CompSpec>),
+ ArrComp(Rc<Expr>, Vec<CompSpec>),
/// Object: {a: 2}
Obj(ObjBody),
/// Object extension: var1 {b: 2}
- ObjExtend(Rc<Spanned<Expr>>, ObjBody),
+ ObjExtend(Rc<Expr>, ObjBody),
/// -2
- UnaryOp(UnaryOpType, Box<Spanned<Expr>>),
+ UnaryOp(UnaryOpType, Box<Expr>),
/// 2 - 2
BinaryOp(Box<BinaryOp>),
/// assert 2 == 2 : "Math is broken"
AssertExpr(Rc<AssertExpr>),
/// local a = 2; { b: a }
- LocalExpr(Vec<BindSpec>, Box<Spanned<Expr>>),
+ LocalExpr(Vec<BindSpec>, Box<Expr>),
/// import* "hello"
- Import(ImportKind, Box<Spanned<Expr>>),
+ Import(Spanned<ImportKind>, Box<Expr>),
/// error "I'm broken"
- ErrorStmt(Box<Spanned<Expr>>),
+ ErrorStmt(Span, Box<Expr>),
/// a(b, c)
- Apply(Box<Spanned<Expr>>, Spanned<ArgsDesc>, bool),
+ Apply(Box<Expr>, Spanned<ArgsDesc>, bool),
/// a[b], a.b, a?.b
Index {
- indexable: Box<Spanned<Expr>>,
+ indexable: Box<Expr>,
parts: Vec<IndexPart>,
},
/// function(x) x
- Function(ExprParams, Rc<Spanned<Expr>>),
+ Function(ExprParams, Rc<Expr>),
/// if true == false then 1 else 2
IfElse(Box<IfElse>),
Slice(Box<Slice>),
@@ -437,7 +437,8 @@
#[derive(Debug, PartialEq, Acyclic)]
pub struct IndexPart {
- pub value: Spanned<Expr>,
+ pub span: Span,
+ pub value: Expr,
#[cfg(feature = "exp-null-coaelse")]
pub null_coaelse: bool,
}
@@ -461,7 +462,7 @@
}
#[derive(Clone, PartialEq, Acyclic)]
-pub struct Spanned<T: Acyclic>(T, Span);
+pub struct Spanned<T: Acyclic>(pub T, pub Span);
impl<T: Acyclic> Deref for Spanned<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
crates/jrsonnet-peg-parser/Cargo.tomldiffbeforeafterboth--- a/crates/jrsonnet-peg-parser/Cargo.toml
+++ b/crates/jrsonnet-peg-parser/Cargo.toml
@@ -7,6 +7,7 @@
version.workspace = true
[dependencies]
+jrsonnet-gcmodule.workspace = true
jrsonnet-ir.workspace = true
peg.workspace = true
crates/jrsonnet-peg-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-peg-parser/src/lib.rs
+++ b/crates/jrsonnet-peg-parser/src/lib.rs
@@ -1,7 +1,9 @@
+use jrsonnet_gcmodule::Acyclic;
use jrsonnet_ir::{
- BinaryOp, Expr, ExprParams, IStr, IndexPart, Member, Slice, SliceDesc, Source, Span, Spanned,
- ExprParam, ArgsDesc, AssertExpr, ImportKind, LiteralType, IfElse, CompSpec, ForSpecData, IfSpecData, ObjMembers, ObjBody,
- ObjComp, FieldMember, Visibility, FieldName, unescape, AssertStmt, BindSpec, Destruct, DestructRest,
+ unescape, ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BindSpec, CompSpec, Destruct,
+ DestructRest, Expr, ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse,
+ IfSpecData, ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice,
+ SliceDesc, Source, Span, Spanned, Visibility,
};
use peg::parser;
use std::rc::Rc;
@@ -63,7 +65,7 @@
= params:param(s) ** comma() comma()? { ExprParams::new(params) }
/ { ExprParams::new(Vec::new()) }
- pub rule arg(s: &ParserSettings) -> (Option<IStr>, Rc<Spanned<Expr>>)
+ pub rule arg(s: &ParserSettings) -> (Option<IStr>, Rc<Expr>)
= name:(quiet! { (s:id() _ "=" !['='] _ {s})? } / expected!("<argument name>")) expr:expr(s) {(name, Rc::new(expr))}
pub rule args(s: &ParserSettings) -> ArgsDesc
@@ -133,7 +135,7 @@
/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ value:expr(s) {BindSpec::Function{name, params, value: Rc::new(value)}}
pub rule assertion(s: &ParserSettings) -> AssertStmt
- = keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { AssertStmt(cond, msg) }
+ = keyword("assert") _ cond:spanned(<expr(s)>, s) msg:(_ ":" _ e:spanned(<expr(s)>, s) {e})? { AssertStmt(cond, msg) }
pub rule whole_line() -> &'input str
= str:$((!['\n'][_])* "\n") {str}
@@ -241,7 +243,7 @@
pub rule forspec(s: &ParserSettings) -> ForSpecData
= keyword("for") _ id:destruct(s) _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}
rule compspec(s: &ParserSettings) -> CompSpec
- = i:ifspec(s) { CompSpec::IfSpec(i) } / f:forspec(s) {CompSpec::ForSpec(f)}
+ = i:spanned(<ifspec(s)>, s) { CompSpec::IfSpec(i) } / f:spanned(<forspec(s)>, s) {CompSpec::ForSpec(f)}
pub rule compspecs(s: &ParserSettings) -> Vec<CompSpec>
= specs:compspec(s) ++ _ {?
if !matches!(specs[0], CompSpec::ForSpec(_)) {
@@ -267,8 +269,12 @@
} else {
Err("!!!numbers are finite")
}}
+
+ rule spanned<T: Acyclic>(x: rule<T>, s: &ParserSettings) -> Spanned<T>
+ = a:position!() n:x() b:position!() { Spanned::new(n, Span(s.source.clone(), a as u32, b as u32)) }
+
pub rule var_expr(s: &ParserSettings) -> Expr
- = n:id() { Expr::Var(n) }
+ = n:spanned(<id()>, s) { Expr::Var(n) }
pub rule id_loc(s: &ParserSettings) -> Spanned<Expr>
= a:position!() n:id() b:position!() { Spanned::new(Expr::Str(n), Span(s.source.clone(), a as u32,b as u32)) }
pub rule if_then_else_expr(s: &ParserSettings) -> Expr
@@ -302,7 +308,7 @@
/ array_expr(s)
/ array_comp_expr(s)
- / kind:import_kind() _ path:expr(s) {Expr::Import(kind, Box::new(path))}
+ / kind:spanned(<import_kind()>, s) _ path:expr(s) {Expr::Import(kind, Box::new(path))}
/ var_expr(s)
/ local_expr(s)
@@ -313,10 +319,10 @@
assert, rest
})) }
- / keyword("error") _ expr:expr(s) { Expr::ErrorStmt(Box::new(expr)) }
+ / err_kw:spanned(<keyword("error")>, s) _ expr:expr(s) { Expr::ErrorStmt(err_kw.1, Box::new(expr)) }
rule slice_part(s: &ParserSettings) -> Option<Spanned<Expr>>
- = _ e:(e:expr(s) _{e})? {e}
+ = _ e:(e:spanned(<expr(s)>, s) _{e})? {e}
pub rule slice_desc(s: &ParserSettings) -> SliceDesc
= start:slice_part(s) ":" pair:(end:slice_part(s) step:(":" e:slice_part(s){e})? {(end, step.flatten())})? {
let (end, step) = if let Some((end, step)) = pair {
@@ -340,11 +346,8 @@
}
use jrsonnet_ir::BinaryOpType::*;
use jrsonnet_ir::UnaryOpType::*;
- rule expr(s: &ParserSettings) -> Spanned<Expr>
+ rule expr(s: &ParserSettings) -> Expr
= precedence! {
- "(" _ e:expr(s) _ ")" {e}
- start:position!() v:@ end:position!() { Spanned::new(v, Span(s.source.clone(), start as u32, end as u32)) }
- --
a:(@) _ binop(<"||">) _ b:@ {expr_bin!(a Or b)}
a:(@) _ binop(<"??">) _ ensure_null_coaelse() b:@ {
#[cfg(feature = "exp-null-coaelse")] return expr_bin!(a NullCoaelse b);
@@ -385,29 +388,32 @@
--
value:(@) _ "[" _ slice:slice_desc(s) _ "]" {Expr::Slice(Box::new(Slice{value, slice}))}
indexable:(@) _ parts:index_part(s)+ {Expr::Index{indexable: Box::new(indexable), parts}}
- a:(@) _ "(" _ args:args(s) _ ")" ts:(_ keyword("tailstrict"))? {Expr::Apply(Box::new(a), args, ts.is_some())}
+ a:(@) _ args:spanned(<"(" _ a:args(s) _ ")" {a}>, s) ts:(_ keyword("tailstrict"))? {Expr::Apply(Box::new(a), args, ts.is_some())}
a:(@) _ "{" _ body:objinside(s) _ "}" {Expr::ObjExtend(Rc::new(a), body)}
--
e:expr_basic(s) {e}
+ "(" _ e:expr(s) _ ")" {e}
}
pub rule index_part(s: &ParserSettings) -> IndexPart
= n:("?" _ ensure_null_coaelse())? "." _ value:id_loc(s) {IndexPart {
- value,
+ span: value.1,
+ value: value.0,
#[cfg(feature = "exp-null-coaelse")]
null_coaelse: n.is_some(),
}}
- / n:("?" _ "." _ ensure_null_coaelse())? "[" _ value:expr(s) _ "]" {IndexPart {
- value,
+ / n:("?" _ "." _ ensure_null_coaelse())? value:spanned(<"[" _ v:expr(s) _ "]" {v}>, s) {IndexPart {
+ span: value.1,
+ value: value.0,
#[cfg(feature = "exp-null-coaelse")]
null_coaelse: n.is_some(),
}}
- pub rule jsonnet(s: &ParserSettings) -> Spanned<Expr> = _ e:expr(s) _ {e}
+ pub rule jsonnet(s: &ParserSettings) -> Expr = _ e:expr(s) _ {e}
}
}
pub type ParseError = peg::error::ParseError<peg::str::LineCol>;
-pub fn parse(str: &str, settings: &ParserSettings) -> Result<Spanned<Expr>, ParseError> {
+pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr, ParseError> {
jsonnet_parser::jsonnet(str, settings)
}
/// Used for importstr values