1use crate::{2 error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,3 LazyBinding, LazyVal, ObjValue, Result, Val,4};5use std::{6 cell::RefCell,7 collections::HashMap,8 fmt::Debug,9 rc::{Rc, Weak},10};1112rc_fn_helper!(13 ContextCreator,14 context_creator,15 dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<Context>16);1718future_wrapper!(Context, FutureContext);1920struct ContextInternals {21 dollar: Option<ObjValue>,22 this: Option<ObjValue>,23 super_obj: Option<ObjValue>,24 bindings: LayeredHashMap<Rc<str>, LazyVal>,25}26impl Debug for ContextInternals {27 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {28 f.debug_struct("Context")29 .field("this", &self.this.as_ref().map(|e| Rc::as_ptr(&e.0)))30 .field("bindings", &self.bindings)31 .finish()32 }33}3435#[derive(Debug, Clone)]36pub struct Context(Rc<ContextInternals>);37impl Context {38 pub fn new_future() -> FutureContext {39 FutureContext(Rc::new(RefCell::new(None)))40 }4142 pub fn dollar(&self) -> &Option<ObjValue> {43 &self.0.dollar44 }4546 pub fn this(&self) -> &Option<ObjValue> {47 &self.0.this48 }4950 pub fn super_obj(&self) -> &Option<ObjValue> {51 &self.0.super_obj52 }5354 pub fn new() -> Context {55 Context(Rc::new(ContextInternals {56 dollar: None,57 this: None,58 super_obj: None,59 bindings: LayeredHashMap::default(),60 }))61 }6263 pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {64 Ok(self65 .066 .bindings67 .get(&name)68 .cloned()69 .ok_or_else(|| UnknownVariable(name))?)70 }71 pub fn into_future(self, ctx: FutureContext) -> Context {72 {73 ctx.0.borrow_mut().replace(self);74 }75 ctx.unwrap()76 }7778 pub fn with_var(self, name: Rc<str>, value: Val) -> Context {79 let mut new_bindings = HashMap::with_capacity(1);80 new_bindings.insert(name, resolved_lazy_val!(value));81 self.extend(new_bindings, None, None, None)82 }8384 pub fn extend(85 self,86 new_bindings: HashMap<Rc<str>, LazyVal>,87 new_dollar: Option<ObjValue>,88 new_this: Option<ObjValue>,89 new_super_obj: Option<ObjValue>,90 ) -> Context {91 match Rc::try_unwrap(self.0) {92 Ok(mut ctx) => {93 94 if let Some(dollar) = new_dollar {95 ctx.dollar = Some(dollar);96 }97 if let Some(this) = new_this {98 ctx.this = Some(this);99 }100 if let Some(super_obj) = new_super_obj {101 ctx.super_obj = Some(super_obj);102 }103 if !new_bindings.is_empty() {104 ctx.bindings = ctx.bindings.extend(new_bindings);105 }106 Context(Rc::new(ctx))107 }108 Err(ctx) => {109 let dollar = new_dollar.or_else(|| ctx.dollar.clone());110 let this = new_this.or_else(|| ctx.this.clone());111 let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());112 let bindings = if new_bindings.is_empty() {113 ctx.bindings.clone()114 } else {115 ctx.bindings.clone().extend(new_bindings)116 };117 Context(Rc::new(ContextInternals {118 dollar,119 this,120 super_obj,121 bindings,122 }))123 }124 }125 }126 pub fn extend_unbound(127 self,128 new_bindings: HashMap<Rc<str>, LazyBinding>,129 new_dollar: Option<ObjValue>,130 new_this: Option<ObjValue>,131 new_super_obj: Option<ObjValue>,132 ) -> Result<Context> {133 let this = new_this.or_else(|| self.0.this.clone());134 let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());135 let mut new = HashMap::with_capacity(new_bindings.len());136 for (k, v) in new_bindings.into_iter() {137 new.insert(k, v.evaluate(this.clone(), super_obj.clone())?);138 }139 Ok(self.extend(new, new_dollar, this, super_obj))140 }141 pub fn into_weak(self) -> WeakContext {142 WeakContext(Rc::downgrade(&self.0))143 }144}145146impl Default for Context {147 fn default() -> Self {148 Self::new()149 }150}151152impl PartialEq for Context {153 fn eq(&self, other: &Self) -> bool {154 Rc::ptr_eq(&self.0, &other.0)155 }156}157158#[derive(Debug, Clone)]159pub struct WeakContext(Weak<ContextInternals>);160impl WeakContext {161 pub fn upgrade(&self) -> Context {162 Context(self.0.upgrade().expect("context is removed"))163 }164}165impl PartialEq for WeakContext {166 fn eq(&self, other: &Self) -> bool {167 self.0.ptr_eq(&other.0)168 }169}