difftreelog
refactor keep source code alongside source path
in: master
18 files changed
bindings/jsonnet/src/import.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -16,6 +16,7 @@
error::{Error::*, Result},
throw, ImportResolver, State,
};
+use jrsonnet_parser::SourcePath;
pub type JsonnetImportCallback = unsafe extern "C" fn(
ctx: *mut c_void,
@@ -29,10 +30,10 @@
pub struct CallbackImportResolver {
cb: JsonnetImportCallback,
ctx: *mut c_void,
- out: RefCell<HashMap<PathBuf, Vec<u8>>>,
+ out: RefCell<HashMap<SourcePath, Vec<u8>>>,
}
impl ImportResolver for CallbackImportResolver {
- fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
+ fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();
let rel = CString::new(path).unwrap().into_raw();
let found_here: *mut c_char = null_mut();
@@ -61,7 +62,7 @@
}
let found_here_raw = unsafe { CStr::from_ptr(found_here) };
- let found_here_buf = PathBuf::from(found_here_raw.to_str().unwrap());
+ let found_here_buf = SourcePath::Path(PathBuf::from(found_here_raw.to_str().unwrap()));
unsafe {
let _ = CString::from_raw(found_here);
}
@@ -74,7 +75,7 @@
Ok(found_here_buf)
}
- fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>> {
+ fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>> {
Ok(self.out.borrow().get(resolved).unwrap().clone())
}
@@ -108,24 +109,28 @@
}
}
impl ImportResolver for NativeImportResolver {
- fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
+ fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
let mut new_path = from.to_owned();
new_path.push(path);
if new_path.exists() {
- Ok(new_path)
+ Ok(SourcePath::Path(new_path))
} else {
for library_path in self.library_paths.borrow().iter() {
let mut cloned = library_path.clone();
cloned.push(path);
if cloned.exists() {
- return Ok(cloned);
+ return Ok(SourcePath::Path(cloned));
}
}
throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))
}
}
- fn load_file_contents(&self, id: &Path) -> Result<Vec<u8>> {
- let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.to_owned()))?;
+ fn load_file_contents(&self, id: &SourcePath) -> Result<Vec<u8>> {
+ let path = match id {
+ SourcePath::Path(path) => path,
+ _ => unreachable!("NativeImportResolver::resolve_file may only return plain paths"),
+ };
+ let mut file = File::open(path).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
let mut out = Vec::new();
file.read_to_end(&mut out)
.map_err(|e| ImportIo(e.to_string()))?;
bindings/jsonnet/src/lib.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -10,9 +10,9 @@
use std::{
alloc::Layout,
+ env,
ffi::{CStr, CString},
os::raw::{c_char, c_double, c_int, c_uint},
- path::PathBuf,
};
use import::NativeImportResolver;
@@ -112,7 +112,10 @@
) -> *const c_char {
let filename = CStr::from_ptr(filename);
match vm
- .import(PathBuf::from(filename.to_str().unwrap()))
+ .import(
+ &env::current_dir().expect("cwd"),
+ filename.to_str().unwrap(),
+ )
.and_then(|v| vm.with_tla(v))
.and_then(|v| vm.manifest(v))
{
@@ -141,10 +144,7 @@
let filename = CStr::from_ptr(filename);
let snippet = CStr::from_ptr(snippet);
match vm
- .evaluate_snippet(
- filename.to_str().unwrap().into(),
- snippet.to_str().unwrap().into(),
- )
+ .evaluate_snippet(filename.to_str().unwrap().into(), snippet.to_str().unwrap())
.and_then(|v| vm.with_tla(v))
.and_then(|v| vm.manifest(v))
{
@@ -186,7 +186,10 @@
) -> *const c_char {
let filename = CStr::from_ptr(filename);
match vm
- .import(PathBuf::from(filename.to_str().unwrap()))
+ .import(
+ &env::current_dir().expect("cwd"),
+ filename.to_str().unwrap(),
+ )
.and_then(|v| vm.with_tla(v))
.and_then(|v| vm.manifest_multi(v))
{
@@ -213,10 +216,7 @@
let filename = CStr::from_ptr(filename);
let snippet = CStr::from_ptr(snippet);
match vm
- .evaluate_snippet(
- filename.to_str().unwrap().into(),
- snippet.to_str().unwrap().into(),
- )
+ .evaluate_snippet(filename.to_str().unwrap().into(), snippet.to_str().unwrap())
.and_then(|v| vm.with_tla(v))
.and_then(|v| vm.manifest_multi(v))
{
@@ -256,7 +256,10 @@
) -> *const c_char {
let filename = CStr::from_ptr(filename);
match vm
- .import(PathBuf::from(filename.to_str().unwrap()))
+ .import(
+ &env::current_dir().expect("cwd"),
+ filename.to_str().unwrap(),
+ )
.and_then(|v| vm.with_tla(v))
.and_then(|v| vm.manifest_stream(v))
{
@@ -283,10 +286,7 @@
let filename = CStr::from_ptr(filename);
let snippet = CStr::from_ptr(snippet);
match vm
- .evaluate_snippet(
- filename.to_str().unwrap().into(),
- snippet.to_str().unwrap().into(),
- )
+ .evaluate_snippet(filename.to_str().unwrap().into(), snippet.to_str().unwrap())
.and_then(|v| vm.with_tla(v))
.and_then(|v| vm.manifest_stream(v))
{
bindings/jsonnet/src/vars_tlas.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -32,7 +32,7 @@
.as_any()
.downcast_ref::<jrsonnet_stdlib::ContextInitializer>()
.expect("only stdlib context initializer supported")
- .add_ext_code(name.to_str().unwrap(), value.to_str().unwrap().into())
+ .add_ext_code(name.to_str().unwrap(), value.to_str().unwrap())
.unwrap()
}
/// # Safety
cmds/jrsonnet/src/main.rsdiffbeforeafterboth--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -133,14 +133,14 @@
let input = opts.input.input.ok_or(Error::MissingInputArgument)?;
let val = if opts.input.exec {
- s.evaluate_snippet("<cmdline>".to_owned(), (&input as &str).into())?
+ s.evaluate_snippet("<cmdline>".to_owned(), &input as &str)?
} else if input == "-" {
let mut input = Vec::new();
std::io::stdin().read_to_end(&mut input)?;
- let input_str = std::str::from_utf8(&input)?.into();
+ let input_str = std::str::from_utf8(&input)?;
s.evaluate_snippet("<stdin>".to_owned(), input_str)?
} else {
- s.import(s.resolve_file(¤t_dir().expect("cwd"), &input)?)?
+ s.import(¤t_dir().expect("cwd"), &input)?
};
let val = s.with_tla(val)?;
crates/jrsonnet-cli/src/stdlib.rsdiffbeforeafterboth1use std::{fs::read_to_string, str::FromStr};23use clap::Parser;4use jrsonnet_evaluator::{error::Result, State};56use crate::ConfigureState;78#[derive(Clone)]9pub struct ExtStr {10 pub name: String,11 pub value: String,12}1314impl FromStr for ExtStr {15 type Err = &'static str;16 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {17 let out: Vec<_> = s.split('=').collect();18 match out.len() {19 1 => Ok(ExtStr {20 name: out[0].to_owned(),21 value: std::env::var(out[0]).or(Err("missing env var"))?,22 }),23 2 => Ok(ExtStr {24 name: out[0].to_owned(),25 value: out[1].to_owned(),26 }),2728 _ => Err("bad ext-str syntax"),29 }30 }31}3233#[derive(Clone)]34pub struct ExtFile {35 pub name: String,36 pub value: String,37}3839impl FromStr for ExtFile {40 type Err = String;4142 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {43 let out: Vec<&str> = s.split('=').collect();44 if out.len() != 2 {45 return Err("bad ext-file syntax".to_owned());46 }47 let file = read_to_string(&out[1]);48 match file {49 Ok(content) => Ok(Self {50 name: out[0].into(),51 value: content,52 }),53 Err(e) => Err(format!("{}", e)),54 }55 }56}5758#[derive(Parser)]59#[clap(next_help_heading = "STANDARD LIBRARY")]60pub struct StdOpts {61 /// Disable standard library.62 /// By default standard library will be available via global `std` variable.63 /// Note that standard library will still be loaded64 /// if chosen manifestification method is not `none`.65 #[clap(long)]66 no_stdlib: bool,67 /// Add string external variable.68 /// External variables are globally available so it is preferred69 /// to use top level arguments whenever it's possible.70 /// If [=data] is not set then it will be read from `name` env variable.71 /// Can be accessed from code via `std.extVar("name")`.72 #[clap(73 long,74 short = 'V',75 name = "name[=var data]",76 number_of_values = 1,77 multiple_occurrences = true78 )]79 ext_str: Vec<ExtStr>,80 /// Read string external variable from file.81 /// See also `--ext-str`82 #[clap(83 long,84 name = "name=var path",85 number_of_values = 1,86 multiple_occurrences = true87 )]88 ext_str_file: Vec<ExtFile>,89 /// Add external variable from code.90 /// See also `--ext-str`91 #[clap(92 long,93 name = "name[=var source]",94 number_of_values = 1,95 multiple_occurrences = true96 )]97 ext_code: Vec<ExtStr>,98 /// Read string external variable from file.99 /// See also `--ext-str`100 #[clap(101 long,102 name = "name=var code path",103 number_of_values = 1,104 multiple_occurrences = true105 )]106 ext_code_file: Vec<ExtFile>,107}108impl ConfigureState for StdOpts {109 fn configure(&self, s: &State) -> Result<()> {110 if self.no_stdlib {111 return Ok(());112 }113 let ctx = jrsonnet_stdlib::ContextInitializer::new(s.clone());114 for ext in self.ext_str.iter() {115 ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());116 }117 for ext in self.ext_str_file.iter() {118 ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());119 }120 for ext in self.ext_code.iter() {121 ctx.add_ext_code(&ext.name as &str, (&ext.value as &str).into())?;122 }123 for ext in self.ext_code_file.iter() {124 ctx.add_ext_code(&ext.name as &str, (&ext.value as &str).into())?;125 }126 s.settings_mut().context_initializer = Box::new(ctx);127 Ok(())128 }129}1use std::{fs::read_to_string, str::FromStr};23use clap::Parser;4use jrsonnet_evaluator::{error::Result, State};56use crate::ConfigureState;78#[derive(Clone)]9pub struct ExtStr {10 pub name: String,11 pub value: String,12}1314impl FromStr for ExtStr {15 type Err = &'static str;16 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {17 let out: Vec<_> = s.split('=').collect();18 match out.len() {19 1 => Ok(ExtStr {20 name: out[0].to_owned(),21 value: std::env::var(out[0]).or(Err("missing env var"))?,22 }),23 2 => Ok(ExtStr {24 name: out[0].to_owned(),25 value: out[1].to_owned(),26 }),2728 _ => Err("bad ext-str syntax"),29 }30 }31}3233#[derive(Clone)]34pub struct ExtFile {35 pub name: String,36 pub value: String,37}3839impl FromStr for ExtFile {40 type Err = String;4142 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {43 let out: Vec<&str> = s.split('=').collect();44 if out.len() != 2 {45 return Err("bad ext-file syntax".to_owned());46 }47 let file = read_to_string(&out[1]);48 match file {49 Ok(content) => Ok(Self {50 name: out[0].into(),51 value: content,52 }),53 Err(e) => Err(format!("{}", e)),54 }55 }56}5758#[derive(Parser)]59#[clap(next_help_heading = "STANDARD LIBRARY")]60pub struct StdOpts {61 /// Disable standard library.62 /// By default standard library will be available via global `std` variable.63 /// Note that standard library will still be loaded64 /// if chosen manifestification method is not `none`.65 #[clap(long)]66 no_stdlib: bool,67 /// Add string external variable.68 /// External variables are globally available so it is preferred69 /// to use top level arguments whenever it's possible.70 /// If [=data] is not set then it will be read from `name` env variable.71 /// Can be accessed from code via `std.extVar("name")`.72 #[clap(73 long,74 short = 'V',75 name = "name[=var data]",76 number_of_values = 1,77 multiple_occurrences = true78 )]79 ext_str: Vec<ExtStr>,80 /// Read string external variable from file.81 /// See also `--ext-str`82 #[clap(83 long,84 name = "name=var path",85 number_of_values = 1,86 multiple_occurrences = true87 )]88 ext_str_file: Vec<ExtFile>,89 /// Add external variable from code.90 /// See also `--ext-str`91 #[clap(92 long,93 name = "name[=var source]",94 number_of_values = 1,95 multiple_occurrences = true96 )]97 ext_code: Vec<ExtStr>,98 /// Read string external variable from file.99 /// See also `--ext-str`100 #[clap(101 long,102 name = "name=var code path",103 number_of_values = 1,104 multiple_occurrences = true105 )]106 ext_code_file: Vec<ExtFile>,107}108impl ConfigureState for StdOpts {109 fn configure(&self, s: &State) -> Result<()> {110 if self.no_stdlib {111 return Ok(());112 }113 let ctx = jrsonnet_stdlib::ContextInitializer::new(s.clone());114 for ext in self.ext_str.iter() {115 ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());116 }117 for ext in self.ext_str_file.iter() {118 ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());119 }120 for ext in self.ext_code.iter() {121 ctx.add_ext_code(&ext.name as &str, &ext.value as &str)?;122 }123 for ext in self.ext_code_file.iter() {124 ctx.add_ext_code(&ext.name as &str, &ext.value as &str)?;125 }126 s.settings_mut().context_initializer = Box::new(ctx);127 Ok(())128 }129}crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -2,7 +2,7 @@
use jrsonnet_gcmodule::Trace;
use jrsonnet_interner::IStr;
-use jrsonnet_parser::{BinaryOpType, ExprLocation, Source, UnaryOpType};
+use jrsonnet_parser::{BinaryOpType, ExprLocation, Source, SourcePath, UnaryOpType};
use jrsonnet_types::ValType;
use thiserror::Error;
@@ -138,10 +138,10 @@
#[error("can't resolve {1} from {0}")]
ImportFileNotFound(PathBuf, String),
- #[error("resolved file not found: {0}")]
- ResolvedFileNotFound(PathBuf),
+ #[error("resolved file not found: {:?}", .0)]
+ ResolvedFileNotFound(SourcePath),
#[error("imported file is not valid utf-8: {0:?}")]
- ImportBadFileUtf8(PathBuf),
+ ImportBadFileUtf8(SourcePath),
#[error("import io error: {0}")]
ImportIo(String),
#[error("tried to import {1} from {0}, but imports is not supported")]
@@ -151,12 +151,11 @@
#[error(
"syntax error: expected {}, got {:?}",
.error.expected,
- .source_code.chars().nth(error.location.offset)
+ .path.code().chars().nth(error.location.offset)
.map_or_else(|| "EOF".into(), |c| c.to_string())
)]
ImportSyntaxError {
path: Source,
- source_code: IStr,
#[trace(skip)]
error: Box<jrsonnet_parser::ParseError>,
},
crates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -416,13 +416,13 @@
Literal(LiteralType::This) => {
Val::Obj(ctx.this().clone().ok_or(CantUseSelfOutsideOfObject)?)
}
- Literal(LiteralType::Super) => {
- Val::Obj(ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(
+ Literal(LiteralType::Super) => Val::Obj(
+ ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(
ctx.this()
.clone()
.expect("if super exists - then this should to"),
- ))
- }
+ ),
+ ),
Literal(LiteralType::Dollar) => {
Val::Obj(ctx.dollar().clone().ok_or(NoTopLevelObjectFound)?)
}
@@ -643,10 +643,10 @@
Import(_) => s.push(
CallLocation::new(loc),
|| format!("import {:?}", path.clone()),
- || s.import(resolved_path.clone()),
+ || s.import_resolved(resolved_path),
)?,
- ImportStr(_) => Val::Str(s.import_str(resolved_path)?),
- ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_bin(resolved_path)?)),
+ ImportStr(_) => Val::Str(s.import_resolved_str(resolved_path)?),
+ ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_resolved_bin(resolved_path)?)),
_ => unreachable!(),
}
}
crates/jrsonnet-evaluator/src/import.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -6,6 +6,7 @@
};
use fs::File;
+use jrsonnet_parser::SourcePath;
use crate::{
error::{Error::*, Result},
@@ -17,9 +18,12 @@
/// Resolves real file path, e.g. `(/home/user/manifests, b.libjsonnet)` can correspond
/// both to `/home/user/manifests/b.libjsonnet` and to `/home/user/${vendor}/b.libjsonnet`
/// where `${vendor}` is a library path.
- fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf>;
+ fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath>;
- fn load_file_contents(&self, resolved: &Path) -> Result<Vec<u8>>;
+ /// Load resolved file
+ /// This should only be called with value returned from `resolve_file`, this cannot be resolved using associated type,
+ /// as evaluator uses object instead of generic for [`ImportResolver`]
+ fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>>;
/// # Safety
///
@@ -32,11 +36,11 @@
/// Dummy resolver, can't resolve/load any file
pub struct DummyImportResolver;
impl ImportResolver for DummyImportResolver {
- fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
+ fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
throw!(ImportNotSupported(from.into(), path.into()))
}
- fn load_file_contents(&self, _resolved: &Path) -> Result<Vec<u8>> {
+ fn load_file_contents(&self, _resolved: &SourcePath) -> Result<Vec<u8>> {
panic!("dummy resolver can't load any file")
}
@@ -59,25 +63,35 @@
pub library_paths: Vec<PathBuf>,
}
impl ImportResolver for FileImportResolver {
- fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
+ fn resolve_file_relative(&self, from: &Path, path: &str) -> Result<SourcePath> {
let mut direct = from.to_path_buf();
direct.push(path);
if direct.exists() {
- Ok(direct.canonicalize().map_err(|e| ImportIo(e.to_string()))?)
+ Ok(SourcePath::Path(
+ direct.canonicalize().map_err(|e| ImportIo(e.to_string()))?,
+ ))
} else {
for library_path in &self.library_paths {
let mut cloned = library_path.clone();
cloned.push(path);
if cloned.exists() {
- return Ok(cloned.canonicalize().map_err(|e| ImportIo(e.to_string()))?);
+ return Ok(SourcePath::Path(
+ cloned.canonicalize().map_err(|e| ImportIo(e.to_string()))?,
+ ));
}
}
throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))
}
}
- fn load_file_contents(&self, id: &Path) -> Result<Vec<u8>> {
- let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.to_owned()))?;
+ fn load_file_contents(&self, id: &SourcePath) -> Result<Vec<u8>> {
+ let path = match id {
+ SourcePath::Path(path) => path,
+ _ => {
+ panic!("this resolver can only resolve to path")
+ }
+ };
+ let mut file = File::open(path).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
let mut out = Vec::new();
file.read_to_end(&mut out)
.map_err(|e| ImportIo(e.to_string()))?;
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -48,7 +48,7 @@
cell::{Ref, RefCell, RefMut},
collections::HashMap,
fmt::{self, Debug},
- path::{Path, PathBuf},
+ path::Path,
rc::Rc,
};
@@ -65,7 +65,7 @@
pub use jrsonnet_parser as parser;
use jrsonnet_parser::*;
pub use obj::*;
-use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};
+use trace::{CompactFormat, TraceFormat};
pub use val::{ManifestFormat, Thunk, Val};
pub trait Unbound: Trace {
@@ -170,10 +170,7 @@
breakpoints: Breakpoints,
/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces
- files: GcHashMap<PathBuf, FileData>,
- /// Contains tla arguments and others, which aren't needed to be obtained by name, however may be used for receiving source
- /// TODO: look into nix approach, storing source code in `Source` object
- volatile_files: GcHashMap<String, String>,
+ files: GcHashMap<SourcePath, FileData>,
}
struct FileData {
string: Option<IStr>,
@@ -249,7 +246,8 @@
pub struct State(Rc<EvaluationStateInternals>);
impl State {
- pub fn import_str(&self, path: PathBuf) -> Result<IStr> {
+ /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise
+ pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {
let mut data = self.data_mut();
let mut file = data.files.raw_entry_mut().from_key(&path);
@@ -283,7 +281,8 @@
}
Ok(file.string.as_ref().expect("just set").clone())
}
- pub fn import_bin(&self, path: PathBuf) -> Result<IBytes> {
+ /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise
+ pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {
let mut data = self.data_mut();
let mut file = data.files.raw_entry_mut().from_key(&path);
@@ -309,7 +308,8 @@
}
Ok(file.bytes.as_ref().expect("just set").clone())
}
- pub fn import(&self, path: PathBuf) -> Result<Val> {
+ /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise
+ pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {
let mut data = self.data_mut();
let mut file = data.files.raw_entry_mut().from_key(&path);
@@ -343,7 +343,8 @@
);
}
let code = file.string.as_ref().expect("just set");
- let file_name = Source::new(path.clone()).expect("resolver should return correct name");
+ let file_name =
+ Source::new(path.clone(), code.clone()).expect("resolver should return correct name");
if file.parsed.is_none() {
file.parsed = Some(
jrsonnet_parser::parse(
@@ -354,7 +355,6 @@
)
.map_err(|e| ImportSyntaxError {
path: file_name.clone(),
- source_code: code.clone(),
error: Box::new(e),
})?,
);
@@ -386,34 +386,11 @@
Ok(v)
}
Err(e) => Err(e),
- }
- }
-
- pub fn get_source(&self, name: Source) -> Option<String> {
- let data = self.data();
- match name.repr() {
- Ok(real) => data
- .files
- .get(real)
- .and_then(|f| f.string.as_ref())
- .map(ToString::to_string),
- Err(e) => data.volatile_files.get(e).map(ToOwned::to_owned),
}
- }
- pub fn map_source_locations(&self, file: Source, locs: &[u32]) -> Vec<CodeLocation> {
- offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)
}
- pub fn map_from_source_location(
- &self,
- file: Source,
- line: usize,
- column: usize,
- ) -> Option<usize> {
- location_to_offset(
- &self.get_source(file).expect("file not found"),
- line,
- column,
- )
+ pub fn import(&self, from: &Path, path: &str) -> Result<Val> {
+ let resolved = self.resolve_file(from, path)?;
+ self.import_resolved(resolved)
}
/// Creates context with all passed global variables
@@ -554,7 +531,10 @@
|| {
func.evaluate(
self.clone(),
- self.create_default_context(Source::new_virtual(Cow::Borrowed("<tla>"))),
+ self.create_default_context(Source::new_virtual(
+ Cow::Borrowed("<tla>"),
+ IStr::empty(),
+ )),
CallLocation::native(),
&self.settings().tla_vars,
true,
@@ -568,9 +548,9 @@
/// Internals
impl State {
- fn data(&self) -> Ref<EvaluationData> {
- self.0.data.borrow()
- }
+ // fn data(&self) -> Ref<EvaluationData> {
+ // self.0.data.borrow()
+ // }
fn data_mut(&self) -> RefMut<EvaluationData> {
self.0.data.borrow_mut()
}
@@ -585,8 +565,9 @@
/// Raw methods evaluate passed values but don't perform TLA execution
impl State {
/// Parses and evaluates the given snippet
- pub fn evaluate_snippet(&self, name: String, code: String) -> Result<Val> {
- let source = Source::new_virtual(Cow::Owned(name.clone()));
+ pub fn evaluate_snippet(&self, name: String, code: impl Into<IStr>) -> Result<Val> {
+ let code = code.into();
+ let source = Source::new_virtual(Cow::Owned(name), code.clone());
let parsed = jrsonnet_parser::parse(
&code,
&ParserSettings {
@@ -595,10 +576,8 @@
)
.map_err(|e| ImportSyntaxError {
path: source.clone(),
- source_code: code.clone().into(),
error: Box::new(e),
})?;
- self.data_mut().volatile_files.insert(name, code);
evaluate(self.clone(), self.create_default_context(source), &parsed)
}
}
@@ -617,7 +596,7 @@
}
pub fn add_tla_code(&self, name: IStr, code: &str) -> Result<()> {
let source_name = format!("<top-level-arg:{}>", name);
- let source = Source::new_virtual(Cow::Owned(source_name.clone()));
+ let source = Source::new_virtual(Cow::Owned(source_name.clone()), code.into());
let parsed = jrsonnet_parser::parse(
code,
&ParserSettings {
@@ -626,22 +605,18 @@
)
.map_err(|e| ImportSyntaxError {
path: source,
- source_code: code.into(),
error: Box::new(e),
})?;
- self.data_mut()
- .volatile_files
- .insert(source_name, code.to_owned());
self.settings_mut()
.tla_vars
.insert(name, TlaArg::Code(parsed));
Ok(())
}
- pub fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
+ pub fn resolve_file(&self, from: &Path, path: &str) -> Result<SourcePath> {
self.settings()
.import_resolver
- .resolve_file(from, path.as_ref())
+ .resolve_file_relative(from, path.as_ref())
}
pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {
crates/jrsonnet-evaluator/src/trace/location.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/trace/location.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-#[allow(clippy::module_name_repetitions)]
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct CodeLocation {
- pub offset: usize,
-
- pub line: usize,
- pub column: usize,
-
- pub line_start_offset: usize,
- pub line_end_offset: usize,
-}
-
-#[allow(clippy::module_name_repetitions)]
-pub fn location_to_offset(mut file: &str, mut line: usize, column: usize) -> Option<usize> {
- let mut offset = 0;
- while line > 1 {
- let pos = file.find('\n')?;
- offset += pos + 1;
- file = &file[pos + 1..];
- line -= 1;
- }
- offset += column - 1;
- Some(offset)
-}
-
-#[allow(clippy::module_name_repetitions)]
-pub fn offset_to_location(file: &str, offsets: &[u32]) -> Vec<CodeLocation> {
- if offsets.is_empty() {
- return vec![];
- }
- let mut line = 1;
- let mut column = 1;
- let max_offset = *offsets.iter().max().expect("offsets is not empty");
-
- let mut offset_map = offsets
- .iter()
- .enumerate()
- .map(|(pos, offset)| (*offset, pos))
- .collect::<Vec<_>>();
- offset_map.sort_by_key(|v| v.0);
- offset_map.reverse();
-
- let mut out = vec![
- CodeLocation {
- offset: 0,
- column: 0,
- line: 0,
- line_start_offset: 0,
- line_end_offset: 0
- };
- offsets.len()
- ];
- let mut with_no_known_line_ending = vec![];
- let mut this_line_offset = 0;
- for (pos, ch) in file
- .chars()
- .enumerate()
- .chain(std::iter::once((file.len(), ' ')))
- {
- column += 1;
- match offset_map.last() {
- Some(x) if x.0 == pos as u32 => {
- let out_idx = x.1;
- with_no_known_line_ending.push(out_idx);
- out[out_idx].offset = pos;
- out[out_idx].line = line;
- out[out_idx].column = column;
- out[out_idx].line_start_offset = this_line_offset;
- offset_map.pop();
- }
- _ => {}
- }
- if ch == '\n' {
- line += 1;
- column = 1;
-
- for idx in with_no_known_line_ending.drain(..) {
- out[idx].line_end_offset = pos;
- }
- this_line_offset = pos + 1;
-
- if pos == max_offset as usize + 1 {
- break;
- }
- }
- }
- let file_end = file.chars().count();
- for idx in with_no_known_line_ending {
- out[idx].line_end_offset = file_end;
- }
-
- out
-}
-
-#[cfg(test)]
-pub mod tests {
- use super::{offset_to_location, CodeLocation};
-
- #[test]
- fn test() {
- assert_eq!(
- offset_to_location(
- "hello world\n_______________________________________________________",
- &[0, 14]
- ),
- vec![
- CodeLocation {
- offset: 0,
- line: 1,
- column: 2,
- line_start_offset: 0,
- line_end_offset: 11,
- },
- CodeLocation {
- offset: 14,
- line: 2,
- column: 4,
- line_start_offset: 12,
- line_end_offset: 67
- }
- ]
- )
- }
-}
crates/jrsonnet-evaluator/src/trace/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/trace/mod.rs
+++ b/crates/jrsonnet-evaluator/src/trace/mod.rs
@@ -1,9 +1,6 @@
-mod location;
-
use std::path::{Path, PathBuf};
-use jrsonnet_parser::Source;
-pub use location::*;
+use jrsonnet_parser::{CodeLocation, Source};
use crate::{error::Error, LocError, State};
@@ -84,31 +81,27 @@
fn write_trace(
&self,
out: &mut dyn std::fmt::Write,
- s: &State,
+ _s: &State,
error: &LocError,
) -> Result<(), std::fmt::Error> {
write!(out, "{}", error.error())?;
- if let Error::ImportSyntaxError {
- path,
- source_code,
- error,
- } = error.error()
- {
+ if let Error::ImportSyntaxError { path, error } = error.error() {
use std::fmt::Write;
writeln!(out)?;
- let mut n = match path.repr() {
- Ok(r) => self.resolver.resolve(r),
- Err(v) => v.to_string(),
+ let mut n = match path.path() {
+ Some(r) => self.resolver.resolve(r),
+ None => path.short_display().to_string(),
};
let mut offset = error.location.offset;
- let is_eof = if offset >= source_code.len() {
- offset = source_code.len().saturating_sub(1);
+ let is_eof = if offset >= path.code().len() {
+ offset = path.code().len().saturating_sub(1);
true
} else {
false
};
- let mut location = offset_to_location(source_code, &[offset as u32])
+ let mut location = path
+ .map_source_locations(&[offset as u32])
.into_iter()
.next()
.unwrap();
@@ -129,13 +122,12 @@
use std::fmt::Write;
#[allow(clippy::option_if_let_else)]
if let Some(location) = location {
- let mut resolved_path = match location.0.repr() {
- Ok(r) => self.resolver.resolve(r),
- Err(v) => v.to_string(),
+ let mut resolved_path = match location.0.path() {
+ Some(r) => self.resolver.resolve(r),
+ None => location.0.short_display().to_string(),
};
// TODO: Process all trace elements first
- let location =
- s.map_source_locations(location.0.clone(), &[location.1, location.2]);
+ let location = location.0.map_source_locations(&[location.1, location.2]);
write!(resolved_path, ":").unwrap();
print_code_location(&mut resolved_path, &location[0], &location[1]).unwrap();
write!(resolved_path, ":").unwrap();
@@ -176,7 +168,7 @@
fn write_trace(
&self,
out: &mut dyn std::fmt::Write,
- s: &State,
+ _s: &State,
error: &LocError,
) -> Result<(), std::fmt::Error> {
write!(out, "{}", error.error())?;
@@ -184,10 +176,10 @@
writeln!(out)?;
let desc = &item.desc;
if let Some(source) = &item.location {
- let start_end = s.map_source_locations(source.0.clone(), &[source.1, source.2]);
- let resolved_path = match source.0.repr() {
- Ok(r) => r.display().to_string(),
- Err(v) => v.to_string(),
+ let start_end = source.0.map_source_locations(&[source.1, source.2]);
+ let resolved_path = match source.0.path() {
+ Some(r) => r.display().to_string(),
+ None => source.0.short_display().to_string(),
};
write!(
@@ -213,19 +205,15 @@
fn write_trace(
&self,
out: &mut dyn std::fmt::Write,
- s: &State,
+ _s: &State,
error: &LocError,
) -> Result<(), std::fmt::Error> {
write!(out, "{}", error.error())?;
- if let Error::ImportSyntaxError {
- path,
- source_code,
- error,
- } = error.error()
- {
+ if let Error::ImportSyntaxError { path, error } = error.error() {
writeln!(out)?;
let offset = error.location.offset;
- let location = offset_to_location(source_code, &[offset as u32])
+ let location = path
+ .map_source_locations(&[offset as u32])
.into_iter()
.next()
.unwrap();
@@ -234,7 +222,7 @@
self.print_snippet(
out,
- source_code,
+ path.code(),
path,
&location,
&end_location,
@@ -246,10 +234,10 @@
writeln!(out)?;
let desc = &item.desc;
if let Some(source) = &item.location {
- let start_end = s.map_source_locations(source.0.clone(), &[source.1, source.2]);
+ let start_end = source.0.map_source_locations(&[source.1, source.2]);
self.print_snippet(
out,
- &s.get_source(source.0.clone()).unwrap(),
+ &source.0.code(),
&source.0,
&start_end[0],
&start_end[1],
@@ -284,9 +272,9 @@
.take(end.line_end_offset - end.line_start_offset)
.collect();
- let origin = match origin.repr() {
- Ok(r) => self.resolver.resolve(r),
- Err(v) => v.to_string(),
+ let origin = match origin.path() {
+ Some(r) => self.resolver.resolve(r),
+ None => origin.short_display().to_string(),
};
let snippet = Snippet {
opt: FormatOptions {
crates/jrsonnet-interner/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -33,6 +33,10 @@
impl IStr {
#[must_use]
+ pub fn empty() -> Self {
+ "".into()
+ }
+ #[must_use]
pub fn as_str(&self) -> &str {
self as &str
}
crates/jrsonnet-parser/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -7,9 +7,11 @@
pub use expr::*;
pub use jrsonnet_interner::IStr;
pub use peg;
+mod location;
mod source;
mod unescape;
-pub use source::Source;
+pub use location::CodeLocation;
+pub use source::{Source, SourcePath};
pub struct ParserSettings {
pub file_name: Source,
crates/jrsonnet-parser/src/location.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-parser/src/location.rs
@@ -0,0 +1,124 @@
+#[allow(clippy::module_name_repetitions)]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct CodeLocation {
+ pub offset: usize,
+
+ pub line: usize,
+ pub column: usize,
+
+ pub line_start_offset: usize,
+ pub line_end_offset: usize,
+}
+
+#[allow(clippy::module_name_repetitions)]
+pub fn location_to_offset(mut file: &str, mut line: usize, column: usize) -> Option<usize> {
+ let mut offset = 0;
+ while line > 1 {
+ let pos = file.find('\n')?;
+ offset += pos + 1;
+ file = &file[pos + 1..];
+ line -= 1;
+ }
+ offset += column - 1;
+ Some(offset)
+}
+
+#[allow(clippy::module_name_repetitions)]
+pub fn offset_to_location(file: &str, offsets: &[u32]) -> Vec<CodeLocation> {
+ if offsets.is_empty() {
+ return vec![];
+ }
+ let mut line = 1;
+ let mut column = 1;
+ let max_offset = *offsets.iter().max().expect("offsets is not empty");
+
+ let mut offset_map = offsets
+ .iter()
+ .enumerate()
+ .map(|(pos, offset)| (*offset, pos))
+ .collect::<Vec<_>>();
+ offset_map.sort_by_key(|v| v.0);
+ offset_map.reverse();
+
+ let mut out = vec![
+ CodeLocation {
+ offset: 0,
+ column: 0,
+ line: 0,
+ line_start_offset: 0,
+ line_end_offset: 0
+ };
+ offsets.len()
+ ];
+ let mut with_no_known_line_ending = vec![];
+ let mut this_line_offset = 0;
+ for (pos, ch) in file
+ .chars()
+ .enumerate()
+ .chain(std::iter::once((file.len(), ' ')))
+ {
+ column += 1;
+ match offset_map.last() {
+ Some(x) if x.0 == pos as u32 => {
+ let out_idx = x.1;
+ with_no_known_line_ending.push(out_idx);
+ out[out_idx].offset = pos;
+ out[out_idx].line = line;
+ out[out_idx].column = column;
+ out[out_idx].line_start_offset = this_line_offset;
+ offset_map.pop();
+ }
+ _ => {}
+ }
+ if ch == '\n' {
+ line += 1;
+ column = 1;
+
+ for idx in with_no_known_line_ending.drain(..) {
+ out[idx].line_end_offset = pos;
+ }
+ this_line_offset = pos + 1;
+
+ if pos == max_offset as usize + 1 {
+ break;
+ }
+ }
+ }
+ let file_end = file.chars().count();
+ for idx in with_no_known_line_ending {
+ out[idx].line_end_offset = file_end;
+ }
+
+ out
+}
+
+#[cfg(test)]
+pub mod tests {
+ use super::{offset_to_location, CodeLocation};
+
+ #[test]
+ fn test() {
+ assert_eq!(
+ offset_to_location(
+ "hello world\n_______________________________________________________",
+ &[0, 14]
+ ),
+ vec![
+ CodeLocation {
+ offset: 0,
+ line: 1,
+ column: 2,
+ line_start_offset: 0,
+ line_end_offset: 11,
+ },
+ CodeLocation {
+ offset: 14,
+ line: 2,
+ column: 4,
+ line_start_offset: 12,
+ line_end_offset: 67
+ }
+ ]
+ )
+ }
+}
crates/jrsonnet-parser/src/source.rsdiffbeforeafterboth--- a/crates/jrsonnet-parser/src/source.rs
+++ b/crates/jrsonnet-parser/src/source.rs
@@ -6,21 +6,42 @@
};
use jrsonnet_gcmodule::{Trace, Tracer};
+use jrsonnet_interner::IStr;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
+use crate::location::{location_to_offset, offset_to_location, CodeLocation};
+
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(PartialEq, Eq, Debug, Hash)]
-enum Inner {
- Real(PathBuf),
+#[derive(PartialEq, Eq, Debug, Hash, Clone)]
+pub enum SourcePath {
+ /// This file is located on disk
+ Path(PathBuf),
+ /// This file is located somewhere else (I.e http), but it can refer to relative paths, and is egilible for caching
+ Custom(String),
+ /// This file is only located in memory, and can't be cached
Virtual(Cow<'static, str>),
}
+impl Trace for SourcePath {
+ fn trace(&self, _tracer: &mut Tracer) {}
+ fn is_type_tracked() -> bool {
+ false
+ }
+}
+
+impl SourcePath {
+ /// Should import resolver be able to read file by this path?
+ pub fn can_load(&self) -> bool {
+ matches!(self, Self::Path(_) | Self::Custom(_))
+ }
+}
+
/// Either real file, or virtual
/// Hash of FileName always have same value as raw Path, to make it possible to use with raw_entry_mut
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct Source(Rc<Inner>);
+pub struct Source(Rc<(SourcePath, IStr)>);
static_assertions::assert_eq_size!(Source, *const ());
impl Trace for Source {
@@ -33,55 +54,63 @@
impl Source {
/// Fails when path contains inner /../ or /./ references, or not absolute
- pub fn new(path: PathBuf) -> Option<Self> {
- if !path.is_absolute()
- || path
- .components()
- .any(|c| matches!(c, Component::CurDir | Component::ParentDir))
- {
- return None;
+ pub fn new(path: SourcePath, code: IStr) -> Option<Self> {
+ if let SourcePath::Path(path) = &path {
+ if !path.is_absolute()
+ || path
+ .components()
+ .any(|c| matches!(c, Component::CurDir | Component::ParentDir))
+ {
+ return None;
+ }
}
- Some(Self(Rc::new(Inner::Real(path))))
+ Some(Self(Rc::new((path, code))))
}
- pub fn new_virtual(n: Cow<'static, str>) -> Self {
- Self(Rc::new(Inner::Virtual(n)))
+ pub fn new_virtual(n: Cow<'static, str>, code: IStr) -> Self {
+ Self(Rc::new((SourcePath::Virtual(n), code)))
}
pub fn short_display(&self) -> ShortDisplay {
ShortDisplay(self.clone())
}
- /// Returns None if file is virtual
+ /// Returns Some if this file is loaded from FS
pub fn path(&self) -> Option<&Path> {
- match self.inner() {
- Inner::Real(r) => Some(r),
- Inner::Virtual(_) => None,
+ match self.source_path() {
+ SourcePath::Path(r) => Some(r),
+ SourcePath::Custom(_) => None,
+ SourcePath::Virtual(_) => None,
}
}
- pub fn repr(&self) -> Result<&Path, &str> {
- match self.inner() {
- Inner::Real(r) => Ok(r),
- Inner::Virtual(v) => Err(v.as_ref()),
- }
+ pub fn code(&self) -> &str {
+ &self.0 .1
+ }
+
+ pub fn source_path(&self) -> &SourcePath {
+ &self.0 .0 as &SourcePath
}
- fn inner(&self) -> &Inner {
- &self.0 as &Inner
+ pub fn map_source_locations(&self, locs: &[u32]) -> Vec<CodeLocation> {
+ offset_to_location(&self.0 .1, locs)
+ }
+ pub fn map_from_source_location(&self, line: usize, column: usize) -> Option<usize> {
+ location_to_offset(&self.0 .1, line, column)
}
}
pub struct ShortDisplay(Source);
impl fmt::Display for ShortDisplay {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- match &self.0 .0 as &Inner {
- Inner::Real(r) => {
+ match &self.0 .0 .0 as &SourcePath {
+ SourcePath::Path(r) => {
write!(
f,
"{}",
r.file_name().expect("path is valid").to_string_lossy()
)
}
- Inner::Virtual(n) => write!(f, "{}", n),
+ SourcePath::Custom(r) => write!(f, "{}", r),
+ SourcePath::Virtual(n) => write!(f, "{}", n),
}
}
}
crates/jrsonnet-stdlib/build.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/build.rs
+++ b/crates/jrsonnet-stdlib/build.rs
@@ -7,7 +7,10 @@
let parsed = parse(
include_str!("./src/std.jsonnet"),
&ParserSettings {
- file_name: Source::new_virtual(Cow::Borrowed("<std>")),
+ file_name: Source::new_virtual(
+ Cow::Borrowed("<std>"),
+ include_str!("./src/std.jsonnet").into(),
+ ),
},
)
.expect("parse");
crates/jrsonnet-stdlib/src/expr.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/expr.rs
+++ b/crates/jrsonnet-stdlib/src/expr.rs
@@ -15,7 +15,7 @@
jrsonnet_parser::parse(
STDLIB_STR,
&ParserSettings {
- file_name: Source::new_virtual(Cow::Borrowed("<std>")),
+ file_name: Source::new_virtual(Cow::Borrowed("<std>"), STDLIB_STR.into()),
},
)
.unwrap()
crates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -183,10 +183,10 @@
pub struct StdTracePrinter;
impl TracePrinter for StdTracePrinter {
- fn print_trace(&self, s: State, loc: CallLocation, value: IStr) {
+ fn print_trace(&self, _s: State, loc: CallLocation, value: IStr) {
eprint!("TRACE:");
if let Some(loc) = loc.0 {
- let locs = s.map_source_locations(loc.0.clone(), &[loc.1]);
+ let locs = loc.0.map_source_locations(&[loc.1]);
eprint!(" {}:{}", loc.0.short_display(), locs[0].line);
}
eprintln!(" {}", value);
@@ -212,9 +212,9 @@
}
}
-pub fn extvar_source(name: &str) -> Source {
+pub fn extvar_source(name: &str, code: impl Into<IStr>) -> Source {
let source_name = format!("<extvar:{}>", name);
- Source::new_virtual(Cow::Owned(source_name))
+ Source::new_virtual(Cow::Owned(source_name), code.into())
}
pub struct ContextInitializer {
@@ -260,8 +260,9 @@
.ext_vars
.insert(name, TlaArg::String(value));
}
- pub fn add_ext_code(&self, name: &str, code: String) -> Result<()> {
- let source = extvar_source(name);
+ pub fn add_ext_code(&self, name: &str, code: impl Into<IStr>) -> Result<()> {
+ let code = code.into();
+ let source = extvar_source(name, code.clone());
let parsed = jrsonnet_parser::parse(
&code,
&jrsonnet_parser::ParserSettings {
@@ -270,7 +271,6 @@
)
.map_err(|e| ImportSyntaxError {
path: source,
- source_code: code.clone().into(),
error: Box::new(e),
})?;
// self.data_mut().volatile_files.insert(source_name, code);
@@ -297,11 +297,13 @@
.hide()
.value(
s,
- Val::Str(match source.repr() {
- Ok(p) => p.display().to_string().into(),
- // Virtual files end up as empty strings in std.thisFile
- Err(_e) => "".into(),
- }),
+ Val::Str(
+ source
+ .path()
+ .map(|p| p.display().to_string())
+ .unwrap_or_else(String::new)
+ .into(),
+ ),
)
.expect("this object builder is empty");
let stdlib_with_this_file = builder.build();
@@ -343,7 +345,7 @@
settings: Rc<RefCell<Settings>>,
))]
fn builtin_ext_var(this: &builtin_ext_var, s: State, x: IStr) -> Result<Any> {
- let ctx = s.create_default_context(extvar_source(&x));
+ let ctx = s.create_default_context(extvar_source(&x, ""));
Ok(Any(this
.settings
.borrow()