avm2: Activation::is_of_type is infallible

Author: relrelb

core/src/avm2.rs

@@ -263,7 +263,7 @@ impl<'gc> Avm2<'gc> {
             if let Some(object) = object {
                 let mut activation = Activation::from_nothing(context.reborrow());
 
-                if object.is_of_type(on_type, &mut activation)? {
+                if object.is_of_type(on_type, &mut activation) {
                     Avm2::dispatch_event(&mut activation.context, event, object)?;
                 }
             }

core/src/avm2/activation.rs

@@ -2644,7 +2644,7 @@ impl<'a, 'gc, 'gc_context> Activation<'a, 'gc, 'gc_context> {
         let multiname = self.pool_multiname_static(method, type_name_index)?;
         let type_object = self.resolve_class(&multiname)?;
 
-        let is_instance_of = value.is_of_type(self, type_object)?;
+        let is_instance_of = value.is_of_type(self, type_object);
         self.context.avm2.push(is_instance_of);
 
         Ok(FrameControl::Continue)
@@ -2660,8 +2660,7 @@ impl<'a, 'gc, 'gc_context> Activation<'a, 'gc, 'gc_context> {
             .ok_or("Cannot check if value is of a type that is null, undefined, or not a class")?;
         let value = self.context.avm2.pop();
 
-        let is_instance_of = value.is_of_type(self, type_object)?;
-
+        let is_instance_of = value.is_of_type(self, type_object);
         self.context.avm2.push(is_instance_of);
 
         Ok(FrameControl::Continue)
@@ -2677,7 +2676,7 @@ impl<'a, 'gc, 'gc_context> Activation<'a, 'gc, 'gc_context> {
         let multiname = self.pool_multiname_static(method, type_name_index)?;
         let class = self.resolve_class(&multiname)?;
 
-        if value.is_of_type(self, class)? {
+        if value.is_of_type(self, class) {
             self.context.avm2.push(value);
         } else {
             self.context.avm2.push(Value::Null);
@@ -2696,7 +2695,7 @@ impl<'a, 'gc, 'gc_context> Activation<'a, 'gc, 'gc_context> {
             .ok_or("Cannot coerce a value to a type that is null, undefined, or not a class")?;
         let value = self.context.avm2.pop();
 
-        if value.is_of_type(self, class)? {
+        if value.is_of_type(self, class) {
             self.context.avm2.push(value);
         } else {
             self.context.avm2.push(Value::Null);

core/src/avm2/globals/json.rs

@@ -233,7 +233,7 @@ impl<'gc> AvmSerializer<'gc> {
                     return Err("TypeError: Error #1129: Cyclic structure cannot be converted to JSON string.".into());
                 }
                 self.obj_stack.push(obj);
-                let value = if obj.is_of_type(activation.avm2().classes().array, activation)? {
+                let value = if obj.is_of_type(activation.avm2().classes().array, activation) {
                     // TODO: Vectors
                     self.serialize_iterable(activation, obj)?
                 } else {

core/src/avm2/globals/string.rs

@@ -223,7 +223,7 @@ fn match_s<'gc>(
         let this = Value::from(this).coerce_to_string(activation)?;
 
         let regexp_class = activation.avm2().classes().regexp;
-        let pattern = if !pattern.is_of_type(activation, regexp_class)? {
+        let pattern = if !pattern.is_of_type(activation, regexp_class) {
             let string = pattern.coerce_to_string(activation)?;
             regexp_class.construct(activation, &[Value::String(string)])?
         } else {

core/src/avm2/globals/vector.rs

@@ -331,7 +331,7 @@ pub fn concat<'gc>(
             let arg_class = arg_obj
                 .instance_of_class_definition()
                 .ok_or("TypeError: Tried to concat from a bare object")?;
-            if !arg.is_of_type(activation, my_class)? {
+            if !arg.is_of_type(activation, my_class) {
                 return Err(format!(
                     "TypeError: Cannot coerce argument of type {:?} to argument of type {:?}",
                     arg_class.read().name(),
@@ -349,7 +349,7 @@ pub fn concat<'gc>(
 
             for val in old_vec {
                 if let Ok(val_obj) = val.coerce_to_object(activation) {
-                    if !val.is_of_type(activation, val_class)? {
+                    if !val.is_of_type(activation, val_class) {
                         let other_val_class = val_obj
                             .instance_of_class_definition()
                             .ok_or("TypeError: Tried to concat a bare object into a Vector")?;

core/src/avm2/object.rs

@@ -810,17 +810,17 @@ pub trait TObject<'gc>: 'gc + Collect + Debug + Into<Object<'gc>> + Clone + Copy
         &self,
         test_class: ClassObject<'gc>,
         activation: &mut Activation<'_, 'gc, '_>,
-    ) -> Result<bool, Error> {
+    ) -> bool {
         let my_class = self.instance_of();
 
         // ES3 objects are not class instances but are still treated as
         // instances of Object, which is an ES4 class.
         if my_class.is_none() && Object::ptr_eq(test_class, activation.avm2().classes().object) {
-            Ok(true)
+            true
         } else if let Some(my_class) = my_class {
             my_class.has_class_in_chain(test_class)
         } else {
-            Ok(false)
+            false
         }
     }
 

core/src/avm2/object/class_object.rs

@@ -426,42 +426,38 @@ impl<'gc> ClassObject<'gc> {
     /// interface we are checking against this class.
     ///
     /// To test if a class *instance* is of a given type, see is_of_type.
-    pub fn has_class_in_chain(self, test_class: ClassObject<'gc>) -> Result<bool, Error> {
+    pub fn has_class_in_chain(self, test_class: ClassObject<'gc>) -> bool {
         let mut my_class = Some(self);
 
         while let Some(class) = my_class {
             if Object::ptr_eq(class, test_class) {
-                return Ok(true);
+                return true;
             }
 
             for interface in class.interfaces() {
                 if Object::ptr_eq(interface, test_class) {
-                    return Ok(true);
+                    return true;
                 }
             }
 
             if let (Some(my_param), Some(test_param)) =
                 (class.as_class_params(), test_class.as_class_params())
             {
-                let mut are_all_params_coercible = true;
-
-                are_all_params_coercible &= match (my_param, test_param) {
-                    (Some(my_param), Some(test_param)) => {
-                        my_param.has_class_in_chain(test_param)?
-                    }
+                let are_all_params_coercible = match (my_param, test_param) {
+                    (Some(my_param), Some(test_param)) => my_param.has_class_in_chain(test_param),
                     (None, Some(_)) => false,
                     _ => true,
                 };
 
                 if are_all_params_coercible {
-                    return Ok(true);
+                    return true;
                 }
             }
 
             my_class = class.superclass_object()
         }
 
-        Ok(false)
+        false
     }
 
     /// Call the instance initializer.

core/src/avm2/value.rs

@@ -940,7 +940,7 @@ impl<'gc> Value<'gc> {
         }
 
         if let Ok(object) = self.coerce_to_object(activation) {
-            if object.is_of_type(class, activation)? {
+            if object.is_of_type(class, activation) {
                 return Ok(object.into());
             }
 
@@ -1013,21 +1013,21 @@ impl<'gc> Value<'gc> {
         &self,
         activation: &mut Activation<'_, 'gc, '_>,
         type_object: ClassObject<'gc>,
-    ) -> Result<bool, Error> {
+    ) -> bool {
         if Object::ptr_eq(type_object, activation.avm2().classes().number) {
-            return Ok(self.is_number());
+            return self.is_number();
         }
         if Object::ptr_eq(type_object, activation.avm2().classes().uint) {
-            return Ok(self.is_u32());
+            return self.is_u32();
         }
         if Object::ptr_eq(type_object, activation.avm2().classes().int) {
-            return Ok(self.is_i32());
+            return self.is_i32();
         }
 
         if let Ok(o) = self.coerce_to_object(activation) {
             o.is_of_type(type_object, activation)
         } else {
-            Ok(false)
+            false
         }
     }