difftreelog
feat macro name interning
in: master
9 files changed
cmds/jrsonnet/Cargo.tomldiffbeforeafterboth--- a/cmds/jrsonnet/Cargo.toml
+++ b/cmds/jrsonnet/Cargo.toml
@@ -11,6 +11,10 @@
workspace = true
[features]
+default = [
+ "exp-regex",
+]
+
experimental = [
"exp-preserve-order",
"exp-destruct",
@@ -18,7 +22,6 @@
"exp-object-iteration",
"exp-bigint",
"exp-apply",
- "exp-regex",
]
# Use mimalloc as allocator
mimalloc = ["mimallocator"]
crates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -5,11 +5,11 @@
rc::Rc,
};
-use jrsonnet_gcmodule::{cc_dyn, Cc};
+use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};
use jrsonnet_interner::IBytes;
use jrsonnet_parser::{Expr, Spanned};
-use crate::{function::NativeFn, Context, Result, Thunk, Val};
+use crate::{function::NativeFn, typed::Typed, Context, Result, Thunk, Val};
mod spec;
pub use spec::{ArrayLike, *};
@@ -241,3 +241,4 @@
self.0.is_cheap()
}
}
+
crates/jrsonnet-evaluator/src/obj/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/obj/mod.rs
+++ b/crates/jrsonnet-evaluator/src/obj/mod.rs
@@ -12,11 +12,12 @@
use educe::Educe;
use jrsonnet_gcmodule::{cc_dyn, Acyclic, Cc, Trace, Weak};
use jrsonnet_interner::IStr;
-use jrsonnet_parser::{Span, Visibility};
+use jrsonnet_parser::Span;
use rustc_hash::{FxHashMap, FxHashSet};
mod oop;
+pub use jrsonnet_parser::Visibility;
pub use oop::ObjValueBuilder;
use crate::{
@@ -30,7 +31,7 @@
};
#[cfg(not(feature = "exp-preserve-order"))]
-mod ordering {
+pub mod ordering {
#![allow(
// This module works as stub for preserve-order feature
clippy::unused_self,
@@ -41,6 +42,9 @@
#[derive(Clone, Copy, Default, Debug, Trace)]
pub struct FieldIndex(());
impl FieldIndex {
+ pub fn absolute(_v: u32) -> Self {
+ Self(())
+ }
pub const fn next(self) -> Self {
Self(())
}
@@ -54,7 +58,7 @@
}
#[cfg(feature = "exp-preserve-order")]
-mod ordering {
+pub mod ordering {
use std::cmp::Reverse;
use jrsonnet_gcmodule::Trace;
@@ -62,6 +66,9 @@
#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]
pub struct FieldIndex(u32);
impl FieldIndex {
+ pub fn absolute(v: u32) -> Self {
+ Self(v)
+ }
pub fn next(self) -> Self {
Self(self.0 + 1)
}
@@ -149,7 +156,7 @@
Pending,
}
-type EnumFieldsHandler<'a> =
+pub type EnumFieldsHandler<'a> =
dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;
pub enum EnumFields {
crates/jrsonnet-interner/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -21,6 +21,8 @@
mod inner;
use inner::Inner;
+mod names;
+
/// Interned string
///
/// Provides O(1) comparsions and hashing, cheap copy, and cheap conversion to [`IBytes`]
crates/jrsonnet-interner/src/names.rsdiffbeforeafterbothno changes
crates/jrsonnet-macros/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -13,6 +13,11 @@
LitStr, Meta, Pat, Path, PathArguments, Result, ReturnType, Token, Type,
};
+use self::typed::derive_typed_inner;
+
+mod typed;
+mod names;
+
fn try_parse_attr_noargs<I>(attrs: &[Attribute], ident: I) -> Result<bool>
where
Ident: PartialEq<I>,
@@ -435,278 +440,6 @@
}
};
})
-}
-
-#[derive(Default)]
-#[allow(clippy::struct_excessive_bools)]
-struct TypedAttr {
- rename: Option<String>,
- aliases: Vec<String>,
- flatten: bool,
- /// flatten(ok) strategy for flattened optionals
- /// field would be None in case of any parsing error (as in serde)
- flatten_ok: bool,
- // Should it be `field+:` instead of `field:`
- add: bool,
- // Should it be `field::` instead of `field:`
- hide: bool,
-}
-impl Parse for TypedAttr {
- fn parse(input: ParseStream) -> syn::Result<Self> {
- let mut out = Self::default();
- loop {
- let lookahead = input.lookahead1();
- if lookahead.peek(kw::rename) {
- input.parse::<kw::rename>()?;
- input.parse::<Token![=]>()?;
- let name = input.parse::<LitStr>()?;
- if out.rename.is_some() {
- return Err(Error::new(
- name.span(),
- "rename attribute may only be specified once",
- ));
- }
- out.rename = Some(name.value());
- } else if lookahead.peek(kw::alias) {
- input.parse::<kw::alias>()?;
- input.parse::<Token![=]>()?;
- let alias = input.parse::<LitStr>()?;
- out.aliases.push(alias.value());
- } else if lookahead.peek(kw::flatten) {
- input.parse::<kw::flatten>()?;
- out.flatten = true;
- if input.peek(token::Paren) {
- let content;
- parenthesized!(content in input);
- let lookahead = content.lookahead1();
- if lookahead.peek(kw::ok) {
- content.parse::<kw::ok>()?;
- out.flatten_ok = true;
- } else {
- return Err(lookahead.error());
- }
- }
- } else if lookahead.peek(kw::add) {
- input.parse::<kw::add>()?;
- out.add = true;
- } else if lookahead.peek(kw::hide) {
- input.parse::<kw::hide>()?;
- out.hide = true;
- } else if input.is_empty() {
- break;
- } else {
- return Err(lookahead.error());
- }
- if input.peek(Token![,]) {
- input.parse::<Token![,]>()?;
- } else {
- break;
- }
- }
- Ok(out)
- }
-}
-
-struct TypedField {
- attr: TypedAttr,
- ident: Ident,
- ty: Type,
- is_option: bool,
- is_lazy: bool,
-}
-impl TypedField {
- fn parse(field: &syn::Field) -> Result<Self> {
- let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();
- let Some(ident) = field.ident.clone() else {
- return Err(Error::new(
- field.span(),
- "this field should appear in output object, but it has no visible name",
- ));
- };
- let (is_option, ty) = extract_type_from_option(&field.ty)?
- .map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));
- if is_option && attr.flatten {
- if !attr.flatten_ok {
- return Err(Error::new(
- field.span(),
- "strategy should be set when flattening Option",
- ));
- }
- } else if attr.flatten_ok {
- return Err(Error::new(
- field.span(),
- "flatten(ok) is only useable on optional fields",
- ));
- }
-
- let is_lazy = type_is_path(&ty, "Thunk").is_some();
-
- Ok(Self {
- attr,
- ident,
- ty,
- is_option,
- is_lazy,
- })
- }
- /// None if this field is flattened in jsonnet output
- fn name(&self) -> Option<String> {
- if self.attr.flatten {
- return None;
- }
- Some(
- self.attr
- .rename
- .clone()
- .unwrap_or_else(|| self.ident.to_string()),
- )
- }
-
- fn expand_field(&self) -> Option<TokenStream> {
- if self.is_option {
- return None;
- }
- let name = self.name()?;
- let ty = &self.ty;
- Some(quote! {
- (#name, <#ty as Typed>::TYPE)
- })
- }
-
- fn expand_parse(&self) -> TokenStream {
- if self.is_option {
- self.expand_parse_optional()
- } else {
- self.expand_parse_mandatory()
- }
- }
-
- fn expand_parse_optional(&self) -> TokenStream {
- let ident = &self.ident;
- let ty = &self.ty;
-
- // optional flatten is handled in same way as serde
- if self.attr.flatten {
- return quote! {
- #ident: <#ty as TypedObj>::parse(&obj).ok(),
- };
- }
-
- let name = self.name().unwrap();
- let aliases = &self.attr.aliases;
-
- quote! {
- #ident: {
- let __value = if let Some(__v) = obj.get(#name.into())? {
- Some(__v)
- } #(else if let Some(__v) = obj.get(#aliases.into())? {
- Some(__v)
- })* else {
- None
- };
-
- __value.map(<#ty as Typed>::from_untyped).transpose()?
- },
- }
- }
-
- fn expand_parse_mandatory(&self) -> TokenStream {
- let ident = &self.ident;
- let ty = &self.ty;
-
- // optional flatten is handled in same way as serde
- if self.attr.flatten {
- return quote! {
- #ident: <#ty as TypedObj>::parse(&obj)?,
- };
- }
-
- let name = self.name().unwrap();
- let aliases = &self.attr.aliases;
-
- let error_text = if aliases.is_empty() {
- // clippy does not understand name variable usage in quote! macro
- #[allow(clippy::redundant_clone)]
- name.clone()
- } else {
- format!("{name} (alias {})", aliases.join(", "))
- };
-
- quote! {
- #ident: {
- let __value = if let Some(__v) = obj.get(#name.into())? {
- __v
- } #(else if let Some(__v) = obj.get(#aliases.into())? {
- __v
- })* else {
- return Err(ErrorKind::NoSuchField(#error_text.into(), vec![]).into());
- };
-
- <#ty as Typed>::from_untyped(__value)?
- },
- }
- }
-
- fn expand_serialize(&self) -> TokenStream {
- let ident = &self.ident;
- let ty = &self.ty;
- self.name().map_or_else(
- || {
- if self.is_option {
- quote! {
- if let Some(value) = self.#ident {
- <#ty as TypedObj>::serialize(value, out)?;
- }
- }
- } else {
- quote! {
- <#ty as TypedObj>::serialize(self.#ident, out)?;
- }
- }
- },
- |name| {
- let hide = if self.attr.hide {
- quote! {.hide()}
- } else {
- quote! {}
- };
- let add = if self.attr.add {
- quote! {.add()}
- } else {
- quote! {}
- };
- let value = if self.is_lazy {
- quote! {
- out.field(#name)
- #hide
- #add
- .try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;
- }
- } else {
- quote! {
- out.field(#name)
- #hide
- #add
- .try_value(<#ty as Typed>::into_untyped(value)?)?;
- }
- };
- if self.is_option {
- quote! {
- if let Some(value) = self.#ident {
- #value
- }
- }
- } else {
- quote! {
- {
- let value = self.#ident;
- #value
- }
- }
- }
- },
- )
- }
}
#[proc_macro_derive(Typed, attributes(typed))]
@@ -717,79 +450,6 @@
Ok(v) => v.into(),
Err(e) => e.to_compile_error().into(),
}
-}
-
-fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {
- let syn::Data::Struct(data) = &input.data else {
- return Err(Error::new(input.span(), "only structs supported"));
- };
-
- let ident = &input.ident;
- let fields = data
- .fields
- .iter()
- .map(TypedField::parse)
- .collect::<Result<Vec<_>>>()?;
-
- let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
-
- let typed = {
- let fields = fields
- .iter()
- .filter_map(TypedField::expand_field)
- .collect::<Vec<_>>();
- quote! {
- impl #impl_generics Typed for #ident #ty_generics #where_clause {
- const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[
- #(#fields,)*
- ]);
-
- fn from_untyped(value: Val) -> JrResult<Self> {
- let obj = value.as_obj().expect("shape is correct");
- Self::parse(&obj)
- }
-
- fn into_untyped(value: Self) -> JrResult<Val> {
- let mut out = ObjValueBuilder::new();
- value.serialize(&mut out)?;
- Ok(Val::Obj(out.build()))
- }
-
- }
- }
- };
-
- let fields_parse = fields.iter().map(TypedField::expand_parse);
- let fields_serialize = fields
- .iter()
- .map(TypedField::expand_serialize)
- .collect::<Vec<_>>();
-
- Ok(quote! {
- const _: () = {
- use ::jrsonnet_evaluator::{
- typed::{ComplexValType, Typed, TypedObj, CheckType},
- Val, State,
- error::{ErrorKind, Result as JrResult},
- ObjValueBuilder, ObjValue,
- };
-
- #typed
-
- impl #impl_generics TypedObj for #ident #ty_generics #where_clause {
- fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {
- #(#fields_serialize)*
-
- Ok(())
- }
- fn parse(obj: &ObjValue) -> JrResult<Self> {
- Ok(Self {
- #(#fields_parse)*
- })
- }
- }
- };
- })
}
struct FormatInput {
crates/jrsonnet-macros/src/names.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-macros/src/names.rs
@@ -0,0 +1,32 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::cell::RefCell;
+
+#[derive(Default)]
+pub struct Names {
+ names: Vec<String>,
+}
+
+impl Names {
+ pub fn intern(&mut self, s: impl AsRef<str>) -> usize {
+ let s = s.as_ref();
+ if let Some(pos) = self.names.iter().position(|v| v == s) {
+ return pos;
+ }
+ let pos = self.names.len();
+ self.names.push(s.to_owned());
+ pos
+ }
+
+ pub fn expand(&self) -> TokenStream {
+ let len = self.names.len();
+ let name = self.names.iter();
+ quote! {
+ thread_local! {
+ static NAMES: [::jrsonnet_evaluator::IStr; #len] = [
+ #(::jrsonnet_evaluator::IStr::from(#name),)*
+ ];
+ }
+ }
+ }
+}
crates/jrsonnet-macros/src/typed.rsdiffbeforeafterbothno changes
crates/jrsonnet-stdlib/src/regex.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/regex.rs
+++ b/crates/jrsonnet-stdlib/src/regex.rs
@@ -4,8 +4,9 @@
use jrsonnet_evaluator::{
error::{ErrorKind::*, Result},
rustc_hash::FxBuildHasher,
+ typed::Typed,
val::StrValue,
- IStr, ObjValueBuilder, Val,
+ IStr, ObjValue, ObjValueBuilder,
};
use jrsonnet_gcmodule::Acyclic;
use jrsonnet_macros::builtin;
@@ -20,7 +21,7 @@
Self {
cache: RefCell::new(LruCache::with_hasher(
NonZeroUsize::new(20).unwrap(),
- FxBuildHasher::default(),
+ FxBuildHasher,
)),
}
}
@@ -40,21 +41,27 @@
}
}
-pub fn regex_match_inner(regex: &Regex, str: String) -> Result<Val> {
- let mut out = ObjValueBuilder::with_capacity(3);
+#[derive(Typed)]
+pub struct RegexMatch {
+ string: IStr,
+ captures: Vec<IStr>,
+ #[typed(rename = "namedCaptures")]
+ named_captures: ObjValue,
+}
+fn regex_match_inner(regex: &Regex, str: String) -> Result<Option<RegexMatch>> {
let mut captures = Vec::with_capacity(regex.captures_len());
let mut named_captures = ObjValueBuilder::with_capacity(regex.capture_names().len());
let Some(captured) = regex.captures(&str) else {
- return Ok(Val::Null);
+ return Ok(None);
};
for ele in captured.iter().skip(1) {
if let Some(ele) = ele {
- captures.push(Val::Str(StrValue::Flat(ele.as_str().into())));
+ captures.push(ele.as_str().into());
} else {
- captures.push(Val::Str(StrValue::Flat(IStr::empty())));
+ captures.push(IStr::empty());
}
}
for (i, name) in regex
@@ -67,13 +74,11 @@
named_captures.field(name).try_value(capture)?;
}
- out.field("string")
- .value(Val::Str(captured.get(0).unwrap().as_str().into()));
- out.field("captures").value(Val::Arr(captures.into()));
- out.field("namedCaptures")
- .value(Val::Obj(named_captures.build()));
-
- Ok(Val::Obj(out.build()))
+ Ok(Some(RegexMatch {
+ string: captured.get(0).expect("regex matched").as_str().into(),
+ named_captures: named_captures.build(),
+ captures,
+ }))
}
#[builtin(fields(
@@ -83,7 +88,7 @@
this: &builtin_regex_partial_match,
pattern: IStr,
str: String,
-) -> Result<Val> {
+) -> Result<Option<RegexMatch>> {
let regex = this.cache.parse(pattern)?;
regex_match_inner(®ex, str)
}
@@ -95,7 +100,7 @@
this: &builtin_regex_full_match,
pattern: StrValue,
str: String,
-) -> Result<Val> {
+) -> Result<Option<RegexMatch>> {
let pattern = format!("^{pattern}$").into();
let regex = this.cache.parse(pattern)?;
regex_match_inner(®ex, str)