avm1: Remove is_slash_path argument in display_object::get_property

Having it set to `true` prevented the '_parent fallback' behavior in some cases
where it shouldn't have (see added test), and it didn't have any other effect.

Removing it also simplifies a lot of code, so this is a win/win!

Author: moulins

core/src/avm1/activation.rs

@@ -1070,7 +1070,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let object_val = self.context.avm1.pop();
         let object = object_val.coerce_to_object(self);
 
-        let result = object.get_non_slash_path(name, self)?;
+        let result = object.get(name, self)?;
         self.stack_push(result);
 
         Ok(FrameControl::Continue)
@@ -2495,7 +2495,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         let root = start.avm1_root();
         let start = start.object1_or_bare(self.gc());
         Ok(self
-            .resolve_target_path(root, start, &path, false, true)?
+            .resolve_target_path(root, start, &path, false)?
             .and_then(|o| o.as_display_object()))
     }
 
@@ -2514,7 +2514,6 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         start: Object<'gc>,
         mut path: &WStr,
         mut first_element: bool,
-        path_has_slash: bool,
     ) -> Result<Option<Object<'gc>>, Error<'gc>> {
         // Empty path resolves immediately to start clip.
         if path.is_empty() {
@@ -2589,26 +2588,15 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                         .and_then(|o| o.as_container())
                         .and_then(|o| o.child_by_name(name, case_sensitive))
                     {
-                        if path_has_slash {
-                            child.object1_or_undef()
-                        } else if child.object1().is_none() {
-                            // If an object doesn't have an object representation,
-                            // e.g. Graphic, then trying to access it returns
-                            // the parent instead
-                            child
-                                .parent()
-                                .map(|p| p.object1_or_undef())
-                                .unwrap_or(Value::Undefined)
-                        } else {
-                            child.object1_or_undef()
-                        }
+                        child
+                            .object1()
+                            // If an object doesn't have an object representation, e.g. Graphic,
+                            // then trying to access it returns the parent instead
+                            .or_else(|| child.parent().and_then(|p| p.object1()))
+                            .map_or(Value::Undefined, Value::from)
                     } else {
                         let name = AvmString::new(self.gc(), name);
-                        if path_has_slash {
-                            object.get(name, self).unwrap()
-                        } else {
-                            object.get_non_slash_path(name, self).unwrap()
-                        }
+                        object.get(name, self).unwrap()
                     }
                 }
             };
@@ -2636,8 +2624,6 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         start: DisplayObject<'gc>,
         path: &'s WStr,
     ) -> Result<Option<(Object<'gc>, &'s WStr)>, Error<'gc>> {
-        let path_has_slash = path.contains(b'/');
-
         // Find the right-most : or . in the path.
         // If we have one, we must resolve as a target path.
         if let Some(separator) = path.rfind(b":.".as_ref()) {
@@ -2648,13 +2634,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             for scope in Scope::ancestors(self.scope()) {
                 let avm1_root = start.avm1_root();
 
-                if let Some(object) = self.resolve_target_path(
-                    avm1_root,
-                    *scope.locals(),
-                    path,
-                    true,
-                    path_has_slash,
-                )? {
+                if let Some(object) =
+                    self.resolve_target_path(avm1_root, *scope.locals(), path, true)?
+                {
                     return Ok(Some((object, var_name)));
                 }
             }
@@ -2692,8 +2674,6 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         // Resolve a variable path for a GetVariable action.
         let start = self.target_clip_or_root();
 
-        let path_has_slash = path.contains(b'/');
-
         // Find the right-most : or . in the path.
         // If we have one, we must resolve as a target path.
         if let Some(separator) = path.rfind(b":.".as_ref()) {
@@ -2704,13 +2684,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             for scope in Scope::ancestors(self.scope()) {
                 let avm1_root = start.avm1_root();
 
-                if let Some(object) = self.resolve_target_path(
-                    avm1_root,
-                    *scope.locals(),
-                    path,
-                    true,
-                    path_has_slash,
-                )? {
+                if let Some(object) =
+                    self.resolve_target_path(avm1_root, *scope.locals(), path, true)?
+                {
                     let var_name = AvmString::new(self.gc(), var_name);
                     if object.has_property(self, var_name) {
                         return Ok(CallableValue::Callable(object, object.get(var_name, self)?));
@@ -2727,7 +2703,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 let avm1_root = start.avm1_root();
 
                 if let Some(object) =
-                    self.resolve_target_path(avm1_root, *scope.locals(), &path, false, true)?
+                    self.resolve_target_path(avm1_root, *scope.locals(), &path, false)?
                 {
                     return Ok(CallableValue::UnCallable(object.into()));
                 }
@@ -2793,7 +2769,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 let avm1_root = start.avm1_root();
 
                 if let Some(object) =
-                    self.resolve_target_path(avm1_root, *scope.locals(), path, true, true)?
+                    self.resolve_target_path(avm1_root, *scope.locals(), path, true)?
                 {
                     let var_name = AvmString::new(self.gc(), var_name);
                     object.set(var_name, value, self)?;
@@ -3011,7 +2987,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         if target.is_empty() {
             new_target_clip = Some(base_clip);
         } else if let Some(clip) = self
-            .resolve_target_path(root, start, target, false, true)?
+            .resolve_target_path(root, start, target, false)?
             .and_then(|o| o.as_display_object())
             .filter(|_| !self.base_clip.avm1_removed())
         // All properties invalid if base clip is removed.

core/src/avm1/globals/array.rs

@@ -643,10 +643,10 @@ fn sort_on_compare<'a, 'gc>(fields: &'a [(AvmString<'gc>, SortOptions)]) -> Comp
         if let [Value::Object(a), Value::Object(b)] = [a, b] {
             for (field_name, options) in fields {
                 let a_prop = a
-                    .get_local_stored(*field_name, activation, false)
+                    .get_local_stored(*field_name, activation)
                     .unwrap_or(Value::Undefined);
                 let b_prop = b
-                    .get_local_stored(*field_name, activation, false)
+                    .get_local_stored(*field_name, activation)
                     .unwrap_or(Value::Undefined);
 
                 let result = sort_compare(activation, &a_prop, &b_prop, *options)?;

core/src/avm1/globals/bitmap_data.rs

@@ -410,7 +410,7 @@ fn clone<'gc>(
     };
 
     Ok(new_bitmap_data(
-        this.get_local_stored(istr!("__proto__"), activation, false),
+        this.get_local_stored(istr!("__proto__"), activation),
         bitmap_data.clone_data(activation.context.gc_context, activation.context.renderer),
         activation,
     )
@@ -795,8 +795,8 @@ fn hit_test<'gc>(
 
     let first_point = args.get_object(activation, 0);
     let top_left = if let (Some(x), Some(y)) = (
-        first_point.get_local_stored(istr!("x"), activation, false),
-        first_point.get_local_stored(istr!("y"), activation, false),
+        first_point.get_local_stored(istr!("x"), activation),
+        first_point.get_local_stored(istr!("y"), activation),
     ) {
         (x.coerce_to_i32(activation)?, y.coerce_to_i32(activation)?)
     } else {
@@ -816,8 +816,8 @@ fn hit_test<'gc>(
 
         let second_point = args.get_object(activation, 3);
         let second_point = if let (Some(x), Some(y)) = (
-            second_point.get_local_stored(istr!("x"), activation, false),
-            second_point.get_local_stored(istr!("y"), activation, false),
+            second_point.get_local_stored(istr!("x"), activation),
+            second_point.get_local_stored(istr!("y"), activation),
         ) {
             (x.coerce_to_i32(activation)?, y.coerce_to_i32(activation)?)
         } else if args.len() > 3 {
@@ -842,10 +842,10 @@ fn hit_test<'gc>(
         // Determine what kind of Object we have, point or rectangle.
         // Duck-typed dumb objects are allowed.
         let compare_fields = (
-            compare_object.get_local_stored(istr!("x"), activation, false),
-            compare_object.get_local_stored(istr!("y"), activation, false),
-            compare_object.get_local_stored(istr!("width"), activation, false),
-            compare_object.get_local_stored(istr!("height"), activation, false),
+            compare_object.get_local_stored(istr!("x"), activation),
+            compare_object.get_local_stored(istr!("y"), activation),
+            compare_object.get_local_stored(istr!("width"), activation),
+            compare_object.get_local_stored(istr!("height"), activation),
         );
         match compare_fields {
             // BitmapData vs. point
@@ -1276,7 +1276,7 @@ fn compare<'gc>(
         other_bitmap_data,
     ) {
         Some(bitmap_data) => Ok(new_bitmap_data(
-            this.get_local_stored(istr!("__proto__"), activation, false),
+            this.get_local_stored(istr!("__proto__"), activation),
             bitmap_data,
             activation,
         )
@@ -1322,7 +1322,7 @@ fn load_bitmap<'gc>(
             .collect(),
     );
     Ok(new_bitmap_data(
-        this.get_local_stored(istr!("prototype"), activation, false),
+        this.get_local_stored(istr!("prototype"), activation),
         bitmap_data,
         activation,
     )

core/src/avm1/globals/bitmap_filter.rs

@@ -65,7 +65,7 @@ pub fn clone<'gc>(
         }
         _ => return Ok(Value::Undefined),
     };
-    let proto = this.get_local_stored(istr!("__proto__"), activation, false);
+    let proto = this.get_local_stored(istr!("__proto__"), activation);
     Ok(create_instance(activation, native, proto).into())
 }
 

core/src/avm1/globals/displacement_map_filter.rs

@@ -120,9 +120,9 @@ impl<'gc> DisplacementMapFilter<'gc> {
         let Some(value) = value else { return Ok(()) };
 
         if let Value::Object(object) = value {
-            if let Some(x) = object.get_local_stored(istr!("x"), activation, false) {
+            if let Some(x) = object.get_local_stored(istr!("x"), activation) {
                 let x = x.coerce_to_f64(activation)?.clamp_to_i32();
-                if let Some(y) = object.get_local_stored(istr!("y"), activation, false) {
+                if let Some(y) = object.get_local_stored(istr!("y"), activation) {
                     let y = y.coerce_to_f64(activation)?.clamp_to_i32();
                     self.0.map_point.set(Point::new(x, y));
                     return Ok(());

core/src/avm1/globals/file_reference.rs

@@ -251,17 +251,15 @@ pub fn browse<'gc>(
 
             for i in 0..length {
                 if let Value::Object(element) = array.get_element(activation, i) {
-                    let mac_type = if let Some(val) =
-                        element.get_local_stored(istr!("macType"), activation, false)
-                    {
-                        Some(val.coerce_to_string(activation)?.to_string())
-                    } else {
-                        None
-                    };
-
-                    let description =
-                        element.get_local_stored(istr!("description"), activation, false);
-                    let extension = element.get_local_stored(istr!("extension"), activation, false);
+                    let mac_type =
+                        if let Some(val) = element.get_local_stored(istr!("macType"), activation) {
+                            Some(val.coerce_to_string(activation)?.to_string())
+                        } else {
+                            None
+                        };
+
+                    let description = element.get_local_stored(istr!("description"), activation);
+                    let extension = element.get_local_stored(istr!("extension"), activation);
 
                     if let (Some(description), Some(extension)) = (description, extension) {
                         let description = description.coerce_to_string(activation)?.to_string();

core/src/avm1/globals/matrix.rs

@@ -148,12 +148,12 @@ pub fn object_to_matrix_or_default<'gc>(
 ) -> Result<Matrix, Error<'gc>> {
     if let (Some(a), Some(b), Some(c), Some(d), Some(tx), Some(ty)) = (
         // These lookups do not search the prototype chain and ignore virtual properties.
-        object.get_local_stored(istr!("a"), activation, false),
-        object.get_local_stored(istr!("b"), activation, false),
-        object.get_local_stored(istr!("c"), activation, false),
-        object.get_local_stored(istr!("d"), activation, false),
-        object.get_local_stored(istr!("tx"), activation, false),
-        object.get_local_stored(istr!("ty"), activation, false),
+        object.get_local_stored(istr!("a"), activation),
+        object.get_local_stored(istr!("b"), activation),
+        object.get_local_stored(istr!("c"), activation),
+        object.get_local_stored(istr!("d"), activation),
+        object.get_local_stored(istr!("tx"), activation),
+        object.get_local_stored(istr!("ty"), activation),
     ) {
         let a = a.coerce_to_f64(activation)? as f32;
         let b = b.coerce_to_f64(activation)? as f32;

core/src/avm1/globals/movie_clip.rs

@@ -153,7 +153,7 @@ pub fn object_to_rectangle<'gc>(
     let mut values = [0; 4];
 
     for (&name, value) in names.iter().zip(&mut values) {
-        *value = match object.get_local_stored(name, activation, false) {
+        *value = match object.get_local_stored(name, activation) {
             Some(value) => value.coerce_to_i32(activation)?,
             None => return Ok(None),
         }
@@ -1378,10 +1378,10 @@ fn local_to_global<'gc>(
         // It does not search the prototype chain and ignores virtual properties.
         if let (Value::Number(x), Value::Number(y)) = (
             point
-                .get_local_stored(istr!("x"), activation, false)
+                .get_local_stored(istr!("x"), activation)
                 .unwrap_or(Value::Undefined),
             point
-                .get_local_stored(istr!("y"), activation, false)
+                .get_local_stored(istr!("y"), activation)
                 .unwrap_or(Value::Undefined),
         ) {
             let local = Point::from_pixels(x, y);
@@ -1560,10 +1560,10 @@ fn global_to_local<'gc>(
         // It does not search the prototype chain and ignores virtual properties.
         if let (Value::Number(x), Value::Number(y)) = (
             point
-                .get_local_stored(istr!("x"), activation, false)
+                .get_local_stored(istr!("x"), activation)
                 .unwrap_or(Value::Undefined),
             point
-                .get_local_stored(istr!("y"), activation, false)
+                .get_local_stored(istr!("y"), activation)
                 .unwrap_or(Value::Undefined),
         ) {
             let global = Point::from_pixels(x, y);

core/src/avm1/object.rs

@@ -144,36 +144,18 @@ impl<'gc> NativeObject<'gc> {
 }
 
 impl<'gc> Object<'gc> {
-    /// Retrieve a named property from the object, or its prototype.
-    pub fn get_non_slash_path(
-        self,
-        name: impl Into<AvmString<'gc>>,
-        activation: &mut Activation<'_, 'gc>,
-    ) -> Result<Value<'gc>, Error<'gc>> {
-        self.lookup(name, activation, false)
-    }
-
     /// Retrieve a named property from the object, or its prototype.
     pub fn get(
         self,
         name: impl Into<AvmString<'gc>>,
         activation: &mut Activation<'_, 'gc>,
-    ) -> Result<Value<'gc>, Error<'gc>> {
-        self.lookup(name, activation, true)
-    }
-
-    fn lookup(
-        self,
-        name: impl Into<AvmString<'gc>>,
-        activation: &mut Activation<'_, 'gc>,
-        is_slash_path: bool,
     ) -> Result<Value<'gc>, Error<'gc>> {
         let (this, proto) = if let Some(super_object) = self.as_super_object() {
             (super_object.this(), super_object.proto(activation))
         } else {
             (self, Value::Object(self))
         };
-        match search_prototype(proto, name.into(), activation, this, is_slash_path, true)? {
+        match search_prototype(proto, name.into(), activation, this, true)? {
             Some((value, _depth)) => Ok(value),
             None => Ok(Value::Undefined),
         }
@@ -193,7 +175,7 @@ impl<'gc> Object<'gc> {
                 return Err(Error::PrototypeRecursionLimit);
             }
 
-            if let Some(value) = p.get_local_stored(name, activation, true) {
+            if let Some(value) = p.get_local_stored(name, activation) {
                 return Ok(value);
             }
 
@@ -280,7 +262,7 @@ impl<'gc> Object<'gc> {
         }
 
         let (method, depth) =
-            match search_prototype(Value::Object(self), name, activation, self, false, true)? {
+            match search_prototype(Value::Object(self), name, activation, self, true)? {
                 Some((Value::Object(method), depth)) => (method, depth),
                 _ => return Ok(Value::Undefined),
             };
@@ -394,7 +376,6 @@ pub fn search_prototype<'gc>(
     name: AvmString<'gc>,
     activation: &mut Activation<'_, 'gc>,
     this: Object<'gc>,
-    is_slash_path: bool,
     call_resolve_fn: bool,
 ) -> Result<Option<(Value<'gc>, u8)>, Error<'gc>> {
     let mut depth = 0;
@@ -425,7 +406,7 @@ pub fn search_prototype<'gc>(
             }
         }
 
-        if let Some(value) = p.get_local_stored(name, activation, is_slash_path) {
+        if let Some(value) = p.get_local_stored(name, activation) {
             return Ok(Some((value, depth)));
         }
 
@@ -456,7 +437,7 @@ pub fn find_resolve_method<'gc>(
             return Err(Error::PrototypeRecursionLimit);
         }
 
-        let resolve = p.get_local_stored(istr!("__resolve"), activation, false);
+        let resolve = p.get_local_stored(istr!("__resolve"), activation);
         // FP completely skips over primitives (but not over non-function objects).
         if let Some(Value::Object(value)) = resolve {
             return Ok(Some(value));