difftreelog
perf cleanup ObjValue
in: master
2 files changed
crates/jrsonnet-evaluator/src/builtin/manifest.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -81,7 +81,7 @@
}
Val::Obj(obj) => {
buf.push('{');
- let fields = obj.visible_fields();
+ let fields = obj.fields();
if !fields.is_empty() {
if mtype != ManifestType::ToString && mtype != ManifestType::Minify {
buf.push('\n');
crates/jrsonnet-evaluator/src/obj.rsdiffbeforeafterboth1use crate::{evaluate_add_op, LazyBinding, Result, Val};2use indexmap::IndexMap;3use jrsonnet_interner::IStr;4use jrsonnet_parser::{ExprLocation, Visibility};5use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};67#[derive(Debug)]8pub struct ObjMember {9 pub add: bool,10 pub visibility: Visibility,11 pub invoke: LazyBinding,12 pub location: Option<ExprLocation>,13}1415// Field => This16type CacheKey = (IStr, usize);17#[derive(Debug)]18pub struct ObjValueInternals {19 super_obj: Option<ObjValue>,20 this_entries: Rc<HashMap<IStr, ObjMember>>,21 value_cache: RefCell<HashMap<CacheKey, Option<Val>>>,22}23#[derive(Clone)]24pub struct ObjValue(pub(crate) Rc<ObjValueInternals>);25impl Debug for ObjValue {26 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {27 if let Some(super_obj) = self.0.super_obj.as_ref() {28 if f.alternate() {29 write!(f, "{:#?}", super_obj)?;30 } else {31 write!(f, "{:?}", super_obj)?;32 }33 write!(f, " + ")?;34 }35 let mut debug = f.debug_struct("ObjValue");36 for (name, member) in self.0.this_entries.iter() {37 debug.field(name, member);38 }39 #[cfg(feature = "unstable")]40 {41 debug.finish_non_exhaustive()42 }43 #[cfg(not(feature = "unstable"))]44 {45 debug.finish()46 }47 }48}4950impl ObjValue {51 pub fn new(super_obj: Option<Self>, this_entries: Rc<HashMap<IStr, ObjMember>>) -> Self {52 Self(Rc::new(ObjValueInternals {53 super_obj,54 this_entries,55 value_cache: RefCell::new(HashMap::new()),56 }))57 }58 pub fn new_empty() -> Self {59 Self::new(None, Rc::new(HashMap::new()))60 }61 pub fn with_super(&self, super_obj: Self) -> Self {62 match &self.0.super_obj {63 None => Self::new(Some(super_obj), self.0.this_entries.clone()),64 Some(v) => Self::new(Some(v.with_super(super_obj)), self.0.this_entries.clone()),65 }66 }67 pub fn enum_fields(&self, handler: &impl Fn(&IStr, &Visibility)) {68 if let Some(s) = &self.0.super_obj {69 s.enum_fields(handler);70 }71 for (name, member) in self.0.this_entries.iter() {72 handler(name, &member.visibility);73 }74 }75 pub fn fields_visibility(&self) -> IndexMap<IStr, bool> {76 let out = Rc::new(RefCell::new(IndexMap::new()));77 self.enum_fields(&|name, visibility| {78 let mut out = out.borrow_mut();79 match visibility {80 Visibility::Normal => {81 if !out.contains_key(name) {82 out.insert(name.to_owned(), true);83 }84 }85 Visibility::Hidden => {86 out.insert(name.to_owned(), false);87 }88 Visibility::Unhide => {89 out.insert(name.to_owned(), true);90 }91 };92 });93 Rc::try_unwrap(out).unwrap().into_inner()94 }95 pub fn visible_fields(&self) -> Vec<IStr> {96 let mut visible_fields: Vec<_> = self97 .fields_visibility()98 .into_iter()99 .filter(|(_k, v)| *v)100 .map(|(k, _)| k)101 .collect();102 visible_fields.sort();103 visible_fields104 }105 pub fn get(&self, key: IStr) -> Result<Option<Val>> {106 Ok(self.get_raw(key, None)?)107 }108 pub(crate) fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {109 let real_this = real_this.unwrap_or(self);110 let cache_key = (key.clone(), Rc::as_ptr(&real_this.0) as usize);111112 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {113 return Ok(v.clone());114 }115 let value = match (self.0.this_entries.get(&key), &self.0.super_obj) {116 (Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),117 (Some(k), Some(s)) => {118 let our = self.evaluate_this(k, real_this)?;119 if k.add {120 s.get_raw(key, Some(real_this))?121 .map_or(Ok(Some(our.clone())), |v| {122 Ok(Some(evaluate_add_op(&v, &our)?))123 })124 } else {125 Ok(Some(our))126 }127 }128 (None, Some(s)) => s.get_raw(key, Some(real_this)),129 (None, None) => Ok(None),130 }?;131 self.0132 .value_cache133 .borrow_mut()134 .insert(cache_key, value.clone());135 Ok(value)136 }137 fn evaluate_this(&self, v: &ObjMember, real_this: &Self) -> Result<Val> {138 Ok(v.invoke139 .evaluate(Some(real_this.clone()), self.0.super_obj.clone())?140 .evaluate()?)141 }142143 pub fn ptr_eq(a: &Self, b: &Self) -> bool {144 Rc::ptr_eq(&a.0, &b.0)145 }146}147impl PartialEq for ObjValue {148 fn eq(&self, other: &Self) -> bool {149 Rc::ptr_eq(&self.0, &other.0)150 }151}1use crate::{evaluate_add_op, LazyBinding, Result, Val};2use jrsonnet_interner::IStr;3use jrsonnet_parser::{ExprLocation, Visibility};4use rustc_hash::FxHashMap;5use std::hash::{Hash, Hasher};6use std::{cell::RefCell, fmt::Debug, rc::Rc};78#[derive(Debug)]9pub struct ObjMember {10 pub add: bool,11 pub visibility: Visibility,12 pub invoke: LazyBinding,13 pub location: Option<ExprLocation>,14}1516// Field => This17type CacheKey = (IStr, ObjValue);18#[derive(Debug)]19pub struct ObjValueInternals {20 super_obj: Option<ObjValue>,21 this_obj: Option<ObjValue>,22 this_entries: Rc<FxHashMap<IStr, ObjMember>>,23 value_cache: RefCell<FxHashMap<CacheKey, Option<Val>>>,24}2526#[derive(Clone)]27pub struct ObjValue(pub(crate) Rc<ObjValueInternals>);28impl Debug for ObjValue {29 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {30 if let Some(super_obj) = self.0.super_obj.as_ref() {31 if f.alternate() {32 write!(f, "{:#?}", super_obj)?;33 } else {34 write!(f, "{:?}", super_obj)?;35 }36 write!(f, " + ")?;37 }38 let mut debug = f.debug_struct("ObjValue");39 for (name, member) in self.0.this_entries.iter() {40 debug.field(name, member);41 }42 #[cfg(feature = "unstable")]43 {44 debug.finish_non_exhaustive()45 }46 #[cfg(not(feature = "unstable"))]47 {48 debug.finish()49 }50 }51}5253impl ObjValue {54 pub fn new(super_obj: Option<Self>, this_entries: Rc<FxHashMap<IStr, ObjMember>>) -> Self {55 Self(Rc::new(ObjValueInternals {56 super_obj,57 this_obj: None,58 this_entries,59 value_cache: RefCell::new(FxHashMap::default()),60 }))61 }62 pub fn new_empty() -> Self {63 Self::new(None, Rc::new(FxHashMap::default()))64 }65 pub fn with_super(&self, super_obj: Self) -> Self {66 match &self.0.super_obj {67 None => Self::new(Some(super_obj), self.0.this_entries.clone()),68 Some(v) => Self::new(Some(v.with_super(super_obj)), self.0.this_entries.clone()),69 }70 }71 pub fn with_this(&self, this_obj: Self) -> Self {72 Self(Rc::new(ObjValueInternals {73 super_obj: self.0.super_obj.clone(),74 this_obj: Some(this_obj),75 this_entries: self.0.this_entries.clone(),76 value_cache: RefCell::new(FxHashMap::default()),77 }))78 }7980 /// Run callback for every field found in object81 pub(crate) fn enum_fields(&self, handler: &mut impl FnMut(&IStr, &Visibility) -> bool) -> bool {82 if let Some(s) = &self.0.super_obj {83 if s.enum_fields(handler) {84 return true;85 }86 }87 for (name, member) in self.0.this_entries.iter() {88 if handler(name, &member.visibility) {89 return true;90 }91 }92 false93 }9495 pub fn fields_visibility(&self) -> FxHashMap<IStr, bool> {96 let mut out = FxHashMap::default();97 self.enum_fields(&mut |name, visibility| {98 match visibility {99 Visibility::Normal => {100 let entry = out.entry(name.to_owned());101 entry.or_insert(true);102 }103 Visibility::Hidden => {104 out.insert(name.to_owned(), false);105 }106 Visibility::Unhide => {107 out.insert(name.to_owned(), true);108 }109 };110 false111 });112 out113 }114 pub fn fields_ex(&self, include_hidden: bool) -> Vec<IStr> {115 let mut fields: Vec<_> = self116 .fields_visibility()117 .into_iter()118 .filter(|(_k, v)| include_hidden || *v)119 .map(|(k, _)| k)120 .collect();121 fields.sort_unstable();122 fields123 }124 pub fn fields(&self) -> Vec<IStr> {125 self.fields_ex(false)126 }127128 pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {129 if let Some(m) = self.0.this_entries.get(&name) {130 Some(match &m.visibility {131 Visibility::Normal => self132 .0133 .super_obj134 .as_ref()135 .and_then(|super_obj| super_obj.field_visibility(name))136 .unwrap_or(Visibility::Normal),137 v => *v,138 })139 } else if let Some(super_obj) = &self.0.super_obj {140 super_obj.field_visibility(name)141 } else {142 None143 }144 }145146 fn has_field_include_hidden(&self, name: IStr) -> bool {147 if self.0.this_entries.contains_key(&name) {148 true149 } else if let Some(super_obj) = &self.0.super_obj {150 super_obj.has_field_include_hidden(name)151 } else {152 false153 }154 }155156 pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {157 if include_hidden {158 self.has_field_include_hidden(name)159 } else {160 self.has_field(name)161 }162 }163 pub fn has_field(&self, name: IStr) -> bool {164 self.field_visibility(name)165 .map(|v| v.is_visible())166 .unwrap_or(false)167 }168169 pub fn get(&self, key: IStr) -> Result<Option<Val>> {170 self.get_raw(key, self.0.this_obj.as_ref())171 }172 pub(crate) fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {173 let real_this = real_this.unwrap_or(self);174 let cache_key = (key.clone(), real_this.clone());175176 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {177 return Ok(v.clone());178 }179 let value = match (self.0.this_entries.get(&key), &self.0.super_obj) {180 (Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),181 (Some(k), Some(s)) => {182 let our = self.evaluate_this(k, real_this)?;183 if k.add {184 s.get_raw(key, Some(real_this))?185 .map_or(Ok(Some(our.clone())), |v| {186 Ok(Some(evaluate_add_op(&v, &our)?))187 })188 } else {189 Ok(Some(our))190 }191 }192 (None, Some(s)) => s.get_raw(key, Some(real_this)),193 (None, None) => Ok(None),194 }?;195 self.0196 .value_cache197 .borrow_mut()198 .insert(cache_key, value.clone());199 Ok(value)200 }201 fn evaluate_this(&self, v: &ObjMember, real_this: &Self) -> Result<Val> {202 v.invoke203 .evaluate(Some(real_this.clone()), self.0.super_obj.clone())?204 .evaluate()205 }206207 pub fn ptr_eq(a: &Self, b: &Self) -> bool {208 Rc::ptr_eq(&a.0, &b.0)209 }210}211212impl PartialEq for ObjValue {213 fn eq(&self, other: &Self) -> bool {214 Rc::ptr_eq(&self.0, &other.0)215 }216}217218impl Eq for ObjValue {}219impl Hash for ObjValue {220 fn hash<H: Hasher>(&self, state: &mut H) {221 state.write_usize(Rc::as_ptr(&self.0) as usize)222 }223}