[core][rewriter] dpsc: implement WrapGetComputed

Author: velzie

rewriter/js/src/changes.rs

@@ -38,6 +38,9 @@ pub enum JsChangeType<'alloc: 'data, 'data> {
     	ident: Atom<'data>,
        	enclose: bool,
 	},
+	WrapGetComputedLeft {
+       	enclose: bool,
+    },
 	WrapGetRight {
         enclose: bool,
     },
@@ -124,6 +127,11 @@ impl<'alloc: 'data, 'data> Transform<'data> for JsChange<'alloc, 'data> {
 			} else {
 		    	transforms![&cfg.wrapgetbase, ident, "("]
 			}),
+			Ty::WrapGetComputedLeft { enclose } => LL::insert(if enclose {
+                transforms!["(", &cfg.wrapcomputedgetfn, "("]
+            } else {
+                transforms![&cfg.wrapcomputedgetfn, "("]
+            }),
 			Ty::WrapGetRight { enclose } => LL::insert(if enclose {
 				transforms!["))"]
 			} else {

rewriter/js/src/rewrite.rs

@@ -33,13 +33,25 @@ pub(crate) enum RewriteType<'alloc: 'data, 'data> {
         propspan: Span,
         enclose: bool,
 	},
+	/// `window["location"]` -> cfg.wrapgetcomputed(window, "location")
+	WrapGetComputed {
+	    leftspan: Span,
+        propspan: Span,
+        enclose: bool,
+	},
 	/// `window.location` -> cfg.wraplocation(window)
 	WrapSet {
     	ident: Atom<'data>,
         propspan: Span,
         leftspan: Span,
         rightspan: Span,
 	},
+	/// `cfg.wrapcomputedsetfn(window, "location", t)`
+	WrapSetComputed {
+        propspan: Span,
+        leftspan: Span,
+        rightspan: Span,
+    },
 	// dead code only if debug is disabled
 	#[allow(dead_code)]
 	/// `$scramerr(name)`
@@ -122,6 +134,16 @@ impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 				change!(span!(end), WrapGetRight {
                     enclose,
                 }),
+			],
+			Self::WrapGetComputed { leftspan, propspan, enclose } => smallvec![
+			    change!(span!(start), WrapGetComputedLeft {
+					enclose
+		        }),
+				// replace the bracket with ,
+				change!(Span::new(leftspan.end, propspan.start), Replace { text: "," }),
+				// replace the other bracket with )
+				change!(Span::new(propspan.end, propspan.end + 1), ClosingParen { semi: false, replace: true }),
+
 			],
 			Self::WrapSet { ident, propspan, leftspan, rightspan } => smallvec![
                 change!(span!(start), WrapSet {
@@ -138,6 +160,7 @@ impl<'alloc: 'data, 'data> RewriteType<'alloc, 'data> {
 					}
 				)
             ],
+            RewriteType::WrapSetComputed { .. } => todo!(),
 			Self::SetRealmFn => smallvec![change!(span, SetRealmFn)],
 			Self::ImportFn => smallvec![change!(span, ImportFn)],
 			Self::MetaFn => smallvec![change!(span, MetaFn)],

rewriter/js/src/visitor.rs

@@ -122,25 +122,35 @@ where
 	}
 
 	fn visit_member_expression(&mut self, it: &MemberExpression<'data>) {
-		// TODO
-		// you could break this with ["postMessage"] etc
-		// however this code only exists because of recaptcha whatever
-		// and it would slow down js execution a lot
-		if let MemberExpression::StaticMemberExpression(s) = it {
-			if s.property.name == "postMessage" {
-				self.jschanges.add(rewrite!(s.property.span, SetRealmFn));
-
-				walk::walk_expression(self, &s.object);
-				return; // unwise to walk the rest of the tree
-			}
+		match  &it {
+		    MemberExpression::StaticMemberExpression(s) =>{
+				// TODO
+				// you could break this with ["postMessage"] etc
+				// however this code only exists because of recaptcha whatever
+				// and it would slow down js execution a lot
+    			if s.property.name == "postMessage" {
+    				self.jschanges.add(rewrite!(s.property.span, SetRealmFn));
+
+    				walk::walk_expression(self, &s.object);
+    				return; // unwise to walk the rest of the tree
+    			}
 
-			if UNSAFE_GLOBALS.contains(&s.property.name.as_str()) {
- 			    self.jschanges.add(rewrite!(it.span(), WrapGet {
-                    ident: s.property.name,
- 			        propspan: Span::new(s.property.span.start-1, s.property.span.end),
+    			if UNSAFE_GLOBALS.contains(&s.property.name.as_str()) {
+     			    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,
+                    }));
+     			}
+			}
+			MemberExpression::ComputedMemberExpression(s) => {
+                self.jschanges.add(rewrite!(it.span(), WrapGetComputed {
+                    leftspan: s.object.span(),
+                    propspan: s.expression.span(),
                     enclose: false,
                 }));
- 			}
+            }
+            _=>{}
 			// if !self.flags.strict_rewrites
 			// 	&& !UNSAFE_GLOBALS.contains(&s.property.name.as_str())
 			// 	&& let Expression::Identifier(_) | Expression::ThisExpression(_) = &s.object