1use crate::{2 error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,3 LazyBinding, LazyVal, ObjValue, Result, Val,4};5use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};67rc_fn_helper!(8 ContextCreator,9 context_creator,10 dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<Context>11);1213future_wrapper!(Context, FutureContext);1415struct ContextInternals {16 dollar: Option<ObjValue>,17 this: Option<ObjValue>,18 super_obj: Option<ObjValue>,19 bindings: LayeredHashMap<Rc<str>, LazyVal>,20}21impl Debug for ContextInternals {22 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {23 f.debug_struct("Context")24 .field("this", &self.this.as_ref().map(|e| Rc::as_ptr(&e.0)))25 .field("bindings", &self.bindings)26 .finish()27 }28}2930#[derive(Debug, Clone)]31pub struct Context(Rc<ContextInternals>);32impl Context {33 pub fn new_future() -> FutureContext {34 FutureContext(Rc::new(RefCell::new(None)))35 }3637 pub fn dollar(&self) -> &Option<ObjValue> {38 &self.0.dollar39 }4041 pub fn this(&self) -> &Option<ObjValue> {42 &self.0.this43 }4445 pub fn super_obj(&self) -> &Option<ObjValue> {46 &self.0.super_obj47 }4849 pub fn new() -> Context {50 Context(Rc::new(ContextInternals {51 dollar: None,52 this: None,53 super_obj: None,54 bindings: LayeredHashMap::default(),55 }))56 }5758 pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {59 Ok(self60 .061 .bindings62 .get(&name)63 .cloned()64 .ok_or_else(|| UnknownVariable(name))?)65 }66 pub fn into_future(self, ctx: FutureContext) -> Context {67 {68 ctx.0.borrow_mut().replace(self);69 }70 ctx.unwrap()71 }7273 pub fn with_var(self, name: Rc<str>, value: Val) -> Context {74 let mut new_bindings = HashMap::with_capacity(1);75 new_bindings.insert(name, resolved_lazy_val!(value));76 self.extend(new_bindings, None, None, None)77 }7879 pub fn extend(80 self,81 new_bindings: HashMap<Rc<str>, LazyVal>,82 new_dollar: Option<ObjValue>,83 new_this: Option<ObjValue>,84 new_super_obj: Option<ObjValue>,85 ) -> Context {86 match Rc::try_unwrap(self.0) {87 Ok(mut ctx) => {88 89 if let Some(dollar) = new_dollar {90 ctx.dollar = Some(dollar);91 }92 if let Some(this) = new_this {93 ctx.this = Some(this);94 }95 if let Some(super_obj) = new_super_obj {96 ctx.super_obj = Some(super_obj);97 }98 if !new_bindings.is_empty() {99 ctx.bindings = ctx.bindings.extend(new_bindings);100 }101 Context(Rc::new(ctx))102 }103 Err(ctx) => {104 let dollar = new_dollar.or_else(|| ctx.dollar.clone());105 let this = new_this.or_else(|| ctx.this.clone());106 let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());107 let bindings = if new_bindings.is_empty() {108 ctx.bindings.clone()109 } else {110 ctx.bindings.clone().extend(new_bindings)111 };112 Context(Rc::new(ContextInternals {113 dollar,114 this,115 super_obj,116 bindings,117 }))118 }119 }120 }121 pub fn extend_unbound(122 self,123 new_bindings: HashMap<Rc<str>, LazyBinding>,124 new_dollar: Option<ObjValue>,125 new_this: Option<ObjValue>,126 new_super_obj: Option<ObjValue>,127 ) -> Result<Context> {128 let this = new_this.or_else(|| self.0.this.clone());129 let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());130 let mut new = HashMap::with_capacity(new_bindings.len());131 for (k, v) in new_bindings.into_iter() {132 new.insert(k, v.evaluate(this.clone(), super_obj.clone())?);133 }134 Ok(self.extend(new, new_dollar, this, super_obj))135 }136 #[cfg(feature = "unstable")]137 pub fn into_weak(self) -> WeakContext {138 WeakContext(Rc::downgrade(&self.0))139 }140}141142impl Default for Context {143 fn default() -> Self {144 Self::new()145 }146}147148impl PartialEq for Context {149 fn eq(&self, other: &Self) -> bool {150 Rc::ptr_eq(&self.0, &other.0)151 }152}153154#[cfg(feature = "unstable")]155#[derive(Debug, Clone)]156pub struct WeakContext(std::rc::Weak<ContextInternals>);157#[cfg(feature = "unstable")]158impl WeakContext {159 pub fn upgrade(&self) -> Context {160 Context(self.0.upgrade().expect("context is removed"))161 }162}163#[cfg(feature = "unstable")]164impl PartialEq for WeakContext {165 fn eq(&self, other: &Self) -> bool {166 self.0.ptr_eq(&other.0)167 }168}