[core][rewriter] dpsc: partially implement WrapAccess

Author: velzie

rewriter/js/src/changes.rs

@@ -30,9 +30,18 @@ pub(crate) use change;
 #[derive(Debug, PartialEq, Eq)]
 pub enum JsChangeType<'alloc: 'data, 'data> {
 	/// insert `${cfg.wrapfn}(`
-	WrapFnLeft { wrap: bool },
+	WrapFnLeft { enclose: bool },
 	/// insert `,strictchecker)`
-	WrapFnRight { wrap: bool },
+	WrapFnRight { enclose: bool },
+
+	WrapAccessLeft {
+    	ident: Atom<'data>,
+       	enclose: bool,
+	},
+	WrapAccessRight {
+        enclose: bool,
+    },
+
 	/// insert `${cfg.setrealmfn}({}).`
 	SetRealmFn,
 	/// insert `${cfg.wrapthis}(`
@@ -94,16 +103,27 @@ impl<'alloc: 'data, 'data> Transform<'data> for JsChange<'alloc, 'data> {
 		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 {
+			Ty::WrapFnRight { enclose } => LL::insert(if enclose {
 				transforms![",", STRICTCHECKER, "))"]
 			} else {
 				transforms![",", STRICTCHECKER, ")"]
 			}),
+			Ty::WrapAccessLeft {
+    			ident,
+        		enclose,
+			} => if enclose {
+			LL::insert(transforms!["(", "$scramjet$wrap", ident, "("])
+			} else {LL::insert(transforms!["$scramjet$wrap", ident, "("])},
+			Ty::WrapAccessRight { enclose } => LL::insert(if enclose {
+						transforms!["))"]
+					} else {
+						transforms![")"]
+					}),
 			Ty::SetRealmFn => LL::insert(transforms![&cfg.setrealmfn, "({})."]),
 			Ty::WrapThisFn => LL::insert(transforms![&cfg.wrapthisfn, "("]),
 			Ty::ScramErrFn { ident } => LL::insert(transforms!["$scramerr(", ident, ");"]),

rewriter/js/src/rewrite.rs

@@ -17,17 +17,24 @@ pub(crate) use rewrite;
 pub(crate) enum RewriteType<'alloc: 'data, 'data> {
 	/// `(cfg.wrapfn(ident,strictchecker))` | `cfg.wrapfn(ident,strictchecker)`
 	WrapFn {
-		wrap: bool,
+		enclose: bool,
 	},
 	/// `cfg.setrealmfn({}).ident`
 	SetRealmFn,
 	/// `cfg.wrapthis(this)`
 	WrapThisFn,
+
 	/// `(cfg.importfn("cfg.base"))`
 	ImportFn,
 	/// `cfg.metafn("cfg.base")`
 	MetaFn,
 
+	/// `window.location` -> cfg.wraplocation(window)
+	WrapAccess {
+    	ident: Atom<'data>,
+        propspan: Span,
+        enclose: bool,
+	},
 	// dead code only if debug is disabled
 	#[allow(dead_code)]
 	/// `$scramerr(name)`
@@ -93,9 +100,23 @@ impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 		}
 
 		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::WrapAccess {
+    			ident,
+                propspan,
+                enclose,
+			} => smallvec![
+	    		change!(span!(start), WrapAccessLeft {
+					ident,
+					enclose,
+				}),
+				change!(propspan, Delete),
+				change!(span!(end), WrapAccessRight {
+                    enclose,
+                }),
 			],
 			Self::SetRealmFn => smallvec![change!(span, SetRealmFn)],
 			Self::WrapThisFn => smallvec![

rewriter/js/src/visitor.rs

@@ -23,16 +23,10 @@ use crate::{
 //
 // maybe move this out of this lib?
 const UNSAFE_GLOBALS: &[&str] = &[
-	"window",
-	"self",
-	"globalThis",
-	"this",
 	"parent",
 	"top",
 	"location",
-	"document",
-	"eval",
-	"frames",
+	"eval"
 ];
 
 pub struct Visitor<'alloc, 'data, E>
@@ -71,17 +65,25 @@ where
 
 	fn rewrite_ident(&mut self, name: &Atom, span: Span) {
 		if UNSAFE_GLOBALS.contains(&name.as_str()) {
-			self.jschanges.add(rewrite!(span, WrapFn { wrap: true }));
+			self.jschanges.add(rewrite!(span, WrapFn { enclose: true }));
 		}
 	}
 
 	fn walk_member_expression(&mut self, it: &Expression) -> bool {
 		match it {
 			Expression::Identifier(s) => {
-				self.rewrite_ident(&s.name, s.span);
-				true
+				false
 			}
-			Expression::StaticMemberExpression(s) => self.walk_member_expression(&s.object),
+			Expression::StaticMemberExpression(s) => {
+    			if UNSAFE_GLOBALS.contains(&s.property.name.as_str()) {
+    			    // self.jschanges.add(rewrite!(s.span, WrapAccess {
+           //          ident: s.property.name,
+           //          propspan: s.property.span,
+           //      }
+           // ));
+    			}
+			    self.walk_member_expression(&s.object)
+			},
 			Expression::ComputedMemberExpression(s) => self.walk_member_expression(&s.object),
 			_ => false,
 		}
@@ -109,7 +111,7 @@ where
 		//
 		if UNSAFE_GLOBALS.contains(&it.name.as_str()) {
 			self.jschanges
-				.add(rewrite!(it.span, WrapFn { wrap: false }));
+				.add(rewrite!(it.span, WrapFn { enclose: false }));
 		}
 		// }
 	}
@@ -132,21 +134,41 @@ where
 				return; // unwise to walk the rest of the tree
 			}
 
-			if !self.flags.strict_rewrites
-				&& !UNSAFE_GLOBALS.contains(&s.property.name.as_str())
-				&& let Expression::Identifier(_) | Expression::ThisExpression(_) = &s.object
-			{
-				// cull tree - this should be safe
-				return;
-			}
+			if UNSAFE_GLOBALS.contains(&s.property.name.as_str()) {
+ 			    self.jschanges.add(rewrite!(it.span(), WrapAccess {
+                    ident: s.property.name,
+ 			        propspan: Span::new(s.property.span.start-1, s.property.span.end),
+                    enclose: false,
+                }));
+ 			}
+			// if !self.flags.strict_rewrites
+			// 	&& !UNSAFE_GLOBALS.contains(&s.property.name.as_str())
+			// 	&& let Expression::Identifier(_) | Expression::ThisExpression(_) = &s.object
+			// {
+			// 	// cull tree - this should be safe
+			// 	return;
+			// }
+
+			// if self.flags.scramitize
+			// 	&& !matches!(s.object, Expression::MetaProperty(_) | Expression::Super(_))
+			// {
+			// 	self.scramitize(s.object.span());
+			// }
+		}
 
-			if self.flags.scramitize
-				&& !matches!(s.object, Expression::MetaProperty(_) | Expression::Super(_))
-			{
-				self.scramitize(s.object.span());
-			}
+		match &it.object() {
+    		Expression::Identifier(_) => {
+                return;
+    		}
+            Expression::ThisExpression(_)=> {
+                // this is safe, we don't need to walk it
+                return;
+    		}
+            _=>{}
 		}
 
+
+
 		walk::walk_member_expression(self, it);
 	}
 	fn visit_this_expression(&mut self, it: &ThisExpression) {