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

Author: velzie

rewriter/js/src/cfg.rs

@@ -17,7 +17,10 @@ pub struct Config {
 	pub prefix: String,
 
 	pub wrapfn: String,
-	pub wrapthisfn: String,
+	pub wrapgetbase: String,
+	pub wrapsetbase: String,
+	pub wrapcomputedgetfn: String,
+	pub wrapcomputedsetfn: String,
 	pub importfn: String,
 	pub rewritefn: String,
 	pub setrealmfn: String,

rewriter/js/src/changes.rs

@@ -34,18 +34,21 @@ pub enum JsChangeType<'alloc: 'data, 'data> {
 	/// insert `,strictchecker)`
 	WrapFnRight { enclose: bool },
 
-	WrapAccessLeft {
+	WrapGetLeft {
     	ident: Atom<'data>,
        	enclose: bool,
 	},
-	WrapAccessRight {
+	WrapGetRight {
         enclose: bool,
     },
 
+    WrapSet {
+       	ident: Atom<'data>,
+        propspan: Span
+    },
+
 	/// insert `${cfg.setrealmfn}({}).`
 	SetRealmFn,
-	/// insert `${cfg.wrapthis}(`
-	WrapThisFn,
 	/// insert `$scramerr(ident);`
 	ScramErrFn { ident: Atom<'data> },
 	/// insert `$scramitize(`
@@ -113,19 +116,25 @@ impl<'alloc: 'data, 'data> Transform<'data> for JsChange<'alloc, 'data> {
 			} else {
 				transforms![",", STRICTCHECKER, ")"]
 			}),
-			Ty::WrapAccessLeft {
+			Ty::WrapGetLeft {
     			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![")"]
-					}),
+			} => LL::insert(if enclose {
+			    transforms!["(", &cfg.wrapgetbase, ident, "("]
+			} else {
+		    	transforms![&cfg.wrapgetbase, ident, "("]
+			}),
+			Ty::WrapGetRight { enclose } => LL::insert(if enclose {
+				transforms!["))"]
+			} else {
+				transforms![")"]
+			}),
+			Ty::WrapSet { ident, propspan } => LL::insert(transforms![
+    			&cfg.wrapsetbase,
+    			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, "("]),

rewriter/js/src/rewrite.rs

@@ -21,20 +21,25 @@ pub(crate) enum RewriteType<'alloc: 'data, 'data> {
 	},
 	/// `cfg.setrealmfn({}).ident`
 	SetRealmFn,
-	/// `cfg.wrapthis(this)`
-	WrapThisFn,
 
 	/// `(cfg.importfn("cfg.base"))`
 	ImportFn,
 	/// `cfg.metafn("cfg.base")`
 	MetaFn,
 
 	/// `window.location` -> cfg.wraplocation(window)
-	WrapAccess {
+	WrapGet {
     	ident: Atom<'data>,
         propspan: Span,
         enclose: bool,
 	},
+	/// `window.location` -> cfg.wraplocation(window)
+	WrapSet {
+    	ident: Atom<'data>,
+        propspan: Span,
+        leftspan: Span,
+        rightspan: Span,
+	},
 	// dead code only if debug is disabled
 	#[allow(dead_code)]
 	/// `$scramerr(name)`
@@ -104,31 +109,36 @@ impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 				change!(span!(start), WrapFnLeft { enclose }),
 				change!(span!(end), WrapFnRight { enclose }),
 			],
-			Self::WrapAccess {
+			Self::WrapGet {
     			ident,
                 propspan,
                 enclose,
 			} => smallvec![
-	    		change!(span!(start), WrapAccessLeft {
+	    		change!(span!(start), WrapGetLeft {
 					ident,
 					enclose,
 				}),
 				change!(propspan, Delete),
-				change!(span!(end), WrapAccessRight {
+				change!(span!(end), WrapGetRight {
                     enclose,
                 }),
 			],
-			Self::SetRealmFn => smallvec![change!(span, SetRealmFn)],
-			Self::WrapThisFn => smallvec![
-				change!(span!(start), WrapThisFn),
-				change!(
+			Self::WrapSet { ident, propspan, leftspan, rightspan } => smallvec![
+                change!(span!(start), WrapSet {
+                    ident,
+                    propspan,
+                }),
+                change!(propspan, Delete),
+                change!(Span::new(leftspan.end, rightspan.start), Replace { text: "," }),
+                change!(
 					span!(end),
 					ClosingParen {
 						semi: false,
-						replace: false
+						replace: true
 					}
-				),
-			],
+				)
+            ],
+			Self::SetRealmFn => smallvec![change!(span, SetRealmFn)],
 			Self::ImportFn => smallvec![change!(span, ImportFn)],
 			Self::MetaFn => smallvec![change!(span, MetaFn)],
 			Self::ScramErr { ident } => smallvec![change!(span!(end), ScramErrFn { ident })],

rewriter/js/src/visitor.rs

@@ -135,7 +135,7 @@ where
 			}
 
 			if UNSAFE_GLOBALS.contains(&s.property.name.as_str()) {
- 			    self.jschanges.add(rewrite!(it.span(), WrapAccess {
+ 			    self.jschanges.add(rewrite!(it.span(), WrapGet {
                     ident: s.property.name,
  			        propspan: Span::new(s.property.span.start-1, s.property.span.end),
                     enclose: false,
@@ -171,9 +171,6 @@ where
 
 		walk::walk_member_expression(self, it);
 	}
-	fn visit_this_expression(&mut self, it: &ThisExpression) {
-		self.jschanges.add(rewrite!(it.span, WrapThisFn));
-	}
 
 	fn visit_debugger_statement(&mut self, it: &DebuggerStatement) {
 		// delete debugger statements entirely. some sites will spam debugger as an anti-debugging measure, and we don't want that!
@@ -291,9 +288,9 @@ where
 		walk::walk_unary_expression(self, it);
 	}
 
-	fn visit_update_expression(&mut self, _it: &UpdateExpression<'data>) {
-		// then no, don't walk it, we don't care
-	}
+	// fn visit_update_expression(&mut self, _it: &UpdateExpression<'data>) {
+	// 	// this is like a ++ or -- operator
+	// }
 
 	fn visit_meta_property(&mut self, it: &MetaProperty<'data>) {
 		if it.meta.name == "import" {
@@ -319,6 +316,19 @@ where
 					return;
 				}
 			}
+			AssignmentTarget::StaticMemberExpression(s) =>{
+                if UNSAFE_GLOBALS.contains(&s.property.name.as_str()) {
+                    self.jschanges.add(rewrite!(it.span, WrapSet {
+                        ident: s.property.name,
+                        propspan: Span::new(s.property.span.start-1, s.property.span.end),
+                        leftspan: s.span(),
+                        rightspan: it.right.span(),
+                    }));
+                }
+
+                // more to walk
+                walk::walk_expression(self, &s.object);
+			}
 			AssignmentTarget::ArrayAssignmentTarget(_) => {
 				// [location] = ["https://example.com"]
 				// this is such a ridiculously specific edge case. just ignore it