[core] Replace proxy-based rewriter with DPSC approach (#4)

* [core][rewriter] dpsc: partially implement WrapAccess

* [core][rewriter] dpsc: implement WrapSet and remove WrapThis

* [core][rewriter] dpsc: implement WrapGetComputed

* [core][rewriter] dpsc: fix nested WrapGet s

* [core][rewriter] dpsc: implement WrapSetComputed

* [core][rewriter] dpsc: fix nested computed gets

* [core][rewriter] dspc: change eval() from a replace rewrite to an insert rewrite to fix nesting issues

* [core][rewriter] dpsc: nuke strictchecker

* [core][rewriter] fix dpsc wrapget (#3)

* fmt

* fix

* [core] add dpsc types to config

* [core][rewriter] dpsc: fix bad rewrite with wrapcomputedgetleft

* [core][rewriter] dpsc: switch from computed wraps to dynamic property wraps

* [core] add dpsc globals

* [core] NUKE GLOBALPROXY

* [core] dpsc: proxy location for document.location too

* [core][rewriter] dpsc: fix eval rewrite

* [core][rewriter] dpsc: handle the comma operator correctly in wrapped properties

* [core] dpsc: oops

---------

Co-authored-by: Toshit Chawda <[email protected]>

Author: velzie

rewriter/js/src/cfg.rs

@@ -17,7 +17,8 @@ pub struct Config {
 	pub prefix: String,
 
 	pub wrapfn: String,
-	pub wrapthisfn: String,
+	pub wrappropertybase: String,
+	pub wrappropertyfn: String,
 	pub importfn: String,
 	pub rewritefn: String,
 	pub setrealmfn: String,

rewriter/js/src/changes.rs

@@ -17,9 +17,6 @@ use crate::{
 	rewrite::Rewrite,
 };
 
-// const STRICTCHECKER: &str = "(function(a){arguments[0]=false;return a})(true)";
-const STRICTCHECKER: &str = "(function(){return!this;})()";
-
 macro_rules! change {
     ($span:expr, $($ty:tt)*) => {
 		$crate::changes::JsChange::new($span, $crate::changes::JsChangeType::$($ty)*)
@@ -30,21 +27,34 @@ pub(crate) use change;
 #[derive(Debug, PartialEq, Eq)]
 pub enum JsChangeType<'alloc: 'data, 'data> {
 	/// insert `${cfg.wrapfn}(`
-	WrapFnLeft { wrap: bool },
-	/// insert `,strictchecker)`
-	WrapFnRight { wrap: bool },
+	WrapFnLeft {
+		enclose: bool,
+	},
+	/// insert `)`
+	WrapFnRight {
+		enclose: bool,
+	},
+
+	WrapPropertyLeft,
+	WrapPropertyRight,
+	RewriteProperty {
+        ident: Atom<'data>,
+    },
+
 	/// insert `${cfg.setrealmfn}({}).`
 	SetRealmFn,
-	/// insert `${cfg.wrapthis}(`
-	WrapThisFn,
 	/// insert `$scramerr(ident);`
-	ScramErrFn { ident: Atom<'data> },
+	ScramErrFn {
+		ident: Atom<'data>,
+	},
 	/// insert `$scramitize(`
 	ScramitizeFn,
 	/// insert `eval(${cfg.rewritefn}(`
 	EvalRewriteFn,
 	/// insert `: ${cfg.wrapfn}(ident)`
-	ShorthandObj { ident: Atom<'data> },
+	ShorthandObj {
+		ident: Atom<'data>,
+	},
 	/// insert scramtag
 	SourceTag,
 
@@ -59,10 +69,15 @@ pub enum JsChangeType<'alloc: 'data, 'data> {
 	},
 
 	/// insert `)`
-	ClosingParen { semi: bool, replace: bool },
+	ClosingParen {
+		semi: bool,
+		replace: bool,
+	},
 
 	/// replace span with text
-	Replace { text: &'alloc str },
+	Replace {
+		text: &'alloc str,
+	},
 	/// replace span with ""
 	Delete,
 }
@@ -91,24 +106,28 @@ impl<'alloc: 'data, 'data> Transform<'data> for JsChange<'alloc, 'data> {
 		(cfg, flags): &Self::ToLowLevelData,
 		offset: i32,
 	) -> TransformLL<'data> {
+    	dbg!(&&self);
 		use JsChangeType as Ty;
 		use TransformLL as LL;
 		match self.ty {
-			Ty::WrapFnLeft { wrap } => LL::insert(if wrap {
+			Ty::WrapFnLeft { enclose } => LL::insert(if enclose {
 				transforms!["(", &cfg.wrapfn, "("]
 			} else {
 				transforms![&cfg.wrapfn, "("]
 			}),
-			Ty::WrapFnRight { wrap } => LL::insert(if wrap {
-				transforms![",", STRICTCHECKER, "))"]
+			Ty::WrapFnRight { enclose } => LL::insert(if enclose {
+				transforms!["))"]
 			} else {
-				transforms![",", STRICTCHECKER, ")"]
+				transforms![")"]
 			}),
+			Ty::WrapPropertyLeft => LL::insert(transforms![&cfg.wrappropertyfn, "(("]),
+			Ty::WrapPropertyRight => LL::insert(transforms!["))"]),
+			Ty::RewriteProperty { ident } => LL::replace(transforms![&cfg.wrappropertybase,ident]),
+
 			Ty::SetRealmFn => LL::insert(transforms![&cfg.setrealmfn, "({})."]),
-			Ty::WrapThisFn => LL::insert(transforms![&cfg.wrapthisfn, "("]),
 			Ty::ScramErrFn { ident } => LL::insert(transforms!["$scramerr(", ident, ");"]),
 			Ty::ScramitizeFn => LL::insert(transforms![" $scramitize("]),
-			Ty::EvalRewriteFn => LL::replace(transforms!["eval(", &cfg.rewritefn, "("]),
+			Ty::EvalRewriteFn => LL::insert(transforms![&cfg.rewritefn, "("]),
 			Ty::ShorthandObj { ident } => {
 				LL::insert(transforms![":", &cfg.wrapfn, "(", ident, ")"])
 			}
@@ -164,6 +183,8 @@ impl Ord for JsChange<'_, '_> {
 			Ordering::Equal => match (&self.ty, &other.ty) {
 				(Ty::ScramErrFn { .. }, _) => Ordering::Less,
 				(_, Ty::ScramErrFn { .. }) => Ordering::Greater,
+                (Ty::WrapFnRight { .. }, _) => Ordering::Less,
+                (_, Ty::WrapFnRight { .. }) => Ordering::Greater,
 				_ => Ordering::Equal,
 			},
 			x => x,

rewriter/js/src/rewrite.rs

@@ -15,19 +15,23 @@ pub(crate) use rewrite;
 
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) enum RewriteType<'alloc: 'data, 'data> {
-	/// `(cfg.wrapfn(ident,strictchecker))` | `cfg.wrapfn(ident,strictchecker)`
+	/// `(cfg.wrapfn(ident))` | `cfg.wrapfn(ident)`
 	WrapFn {
-		wrap: bool,
+		enclose: bool,
 	},
 	/// `cfg.setrealmfn({}).ident`
 	SetRealmFn,
-	/// `cfg.wrapthis(this)`
-	WrapThisFn,
+
 	/// `(cfg.importfn("cfg.base"))`
 	ImportFn,
 	/// `cfg.metafn("cfg.base")`
 	MetaFn,
 
+	RewriteProperty {
+	    ident: Atom<'data>,
+	},
+	WrapProperty,
+
 	// dead code only if debug is disabled
 	#[allow(dead_code)]
 	/// `$scramerr(name)`
@@ -60,6 +64,7 @@ pub(crate) enum RewriteType<'alloc: 'data, 'data> {
 	Delete,
 }
 
+#[derive(Debug)]
 pub(crate) struct Rewrite<'alloc, 'data> {
 	span: Span,
 	ty: RewriteType<'alloc, 'data>,
@@ -77,6 +82,8 @@ impl<'alloc: 'data, 'data> Rewrite<'alloc, 'data> {
 
 impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 	fn into_inner(self, span: Span) -> SmallVec<[JsChange<'alloc, 'data>; 2]> {
+
+	dbg!(&self);
 		macro_rules! span {
 			(start) => {
 				Span::new(span.start, span.start)
@@ -90,24 +97,24 @@ impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 			($span1:ident $span2:ident end) => {
 				Span::new($span1.end, $span2.end)
 			};
+			($span1:ident $span2:ident between) => {
+				Span::new($span1.end, $span2.start)
+			};
 		}
 
 		match self {
-			Self::WrapFn { wrap } => smallvec![
-				change!(span!(start), WrapFnLeft { wrap }),
-				change!(span!(end), WrapFnRight { wrap }),
+			Self::WrapFn { enclose } => smallvec![
+				change!(span!(start), WrapFnLeft { enclose }),
+				change!(span!(end), WrapFnRight { enclose }),
 			],
+			Self::RewriteProperty { ident } => smallvec![
+                change!(span, RewriteProperty { ident }),
+            ],
+            Self::WrapProperty => smallvec![
+                change!(span!(start), WrapPropertyLeft),
+                change!(span!(end), WrapPropertyRight),
+            ],
 			Self::SetRealmFn => smallvec![change!(span, SetRealmFn)],
-			Self::WrapThisFn => smallvec![
-				change!(span!(start), WrapThisFn),
-				change!(
-					span!(end),
-					ClosingParen {
-						semi: false,
-						replace: false
-					}
-				),
-			],
 			Self::ImportFn => smallvec![change!(span, ImportFn)],
 			Self::MetaFn => smallvec![change!(span, MetaFn)],
 			Self::ScramErr { ident } => smallvec![change!(span!(end), ScramErrFn { ident })],
@@ -122,12 +129,12 @@ impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 				)
 			],
 			Self::Eval { inner } => smallvec![
-				change!(span!(span inner start), EvalRewriteFn),
+				change!(Span::new(inner.start, inner.start), EvalRewriteFn),
 				change!(
-					span!(inner span end),
+					Span::new(inner.end, inner.end),
 					ClosingParen {
 						semi: false,
-						replace: true
+						replace: false,
 					}
 				)
 			],