not-python-rust/src/obj.rs

// TODO obj.rs - remove the warning suppression
#![allow(unused_variables, dead_code)]

use std::any::Any;
use std::collections::HashMap;
use std::fmt::{self, Debug, Display};
use std::ptr;
use std::rc::Rc;

use gc::{Finalize, Gc, GcCell, Trace};

use crate::vm::{Argc, Chunk, Frame, Vm};

pub type Ptr<T> = Gc<GcCell<T>>;
pub type ObjP = Ptr<dyn Obj>;
pub type Attrs = HashMap<String, ObjP>;

/// Downcast an object pointer to a concrete type, and do something with that object.
pub fn with_obj_downcast<T, Out>(ptr: ObjP, closure: impl FnOnce(&T) -> Out) -> Out
where
    T: Obj + 'static,
{
    let borrowed = ptr.borrow();
    if let Some(obj) = borrowed.as_any().downcast_ref::<T>() {
        closure(obj)
    } else {
        panic!(
            "could not downcast '{:?}' to {}",
            ptr,
            std::any::type_name::<T>()
        )
    }
}

pub fn obj_is_inst<T>(ptr: &ObjP) -> bool
where
    T: Obj + 'static,
{
    let borrowed = ptr.borrow();
    borrowed.as_any().downcast_ref::<T>().is_some()
}

pub fn upcast_obj<T: Obj>(ptr: Ptr<T>) -> ObjP {
    unsafe {
        let ptr = Ptr::into_raw(ptr) as *const GcCell<dyn Obj>;
        Ptr::from_raw(ptr)
    }
}

pub fn init_types(builtins: &mut HashMap<String, ObjP>) {
    #![allow(non_snake_case)]
    macro_rules! types {
        (base_type: $base_type:ident, $($name:ident),* $(,)?) => {
            $(
                let $name = make_ptr(TypeInst::new(stringify!($name)));
            )*

            $(
                $name.borrow_mut().instantiate(upcast_obj(Gc::clone(&$base_type)));
            )*

            $(
                builtins.insert(stringify!($name).to_string(), upcast_obj($name));
            )*
        };
    }
    types! {
        // base type
        base_type: Type,
        // type definitions
        Type,
        Obj,
        Str,
        Int,
        Float,
        Bool,
        Nil,
        BuiltinFunction,
        UserFunction,
        Method,
    }
}

pub trait ObjFactory {
    fn builtins(&self) -> &HashMap<String, ObjP>;

    fn create_obj(&self) -> ObjP {
        upcast_obj(ObjInst::create(ObjP::clone(
            self.builtins().get("Obj").unwrap(),
        )))
    }

    fn create_type(&self, name: impl ToString) -> ObjP {
        upcast_obj(TypeInst::create(
            ObjP::clone(self.builtins().get("Type").unwrap()),
            name,
        ))
    }

    fn create_str(&self, str_value: impl ToString) -> ObjP {
        upcast_obj(StrInst::create(
            ObjP::clone(self.builtins().get("Str").unwrap()),
            str_value,
        ))
    }

    fn create_int(&self, int_value: i64) -> ObjP {
        upcast_obj(IntInst::create(
            ObjP::clone(self.builtins().get("Int").unwrap()),
            int_value,
        ))
    }

    fn create_float(&self, float_value: f64) -> ObjP {
        upcast_obj(FloatInst::create(
            ObjP::clone(self.builtins().get("Float").unwrap()),
            float_value,
        ))
    }

    fn create_bool(&self, bool_value: bool) -> ObjP {
        upcast_obj(BoolInst::create(
            ObjP::clone(self.builtins().get("Bool").unwrap()),
            bool_value,
        ))
    }

    fn create_nil(&self) -> ObjP {
        upcast_obj(NilInst::create(ObjP::clone(
            self.builtins().get("Nil").unwrap(),
        )))
    }

    fn create_builtin_function(
        &self,
        name: impl ToString,
        function: BuiltinFunctionPtr,
        arity: Argc,
    ) -> ObjP {
        upcast_obj(BuiltinFunctionInst::create(
            ObjP::clone(self.builtins().get("BuiltinFunction").unwrap()),
            name,
            function,
            arity,
        ))
    }

    fn create_user_function(&self, chunk: Chunk, arity: Argc) -> ObjP {
        upcast_obj(UserFunctionInst::create(
            ObjP::clone(self.builtins().get("UserFunction").unwrap()),
            chunk,
            arity,
        ))
    }

    fn create_method(&self, self_binding: ObjP, function: ObjP) -> ObjP {
        upcast_obj(MethodInst::create(
            ObjP::clone(self.builtins().get("Method").unwrap()),
            self_binding,
            function,
        ))
    }
}

impl ObjFactory for HashMap<String, ObjP> {
    fn builtins(&self) -> &Self {
        self
    }
}

/// Convenience function for creating pointers, in case the `Arc<RwLock<T>>` pointer type has to
/// change.
///
/// I would implement this as a `From<T>` but it doesn't seem to work for a foreign type, and I'm
/// not sure why.
pub fn make_ptr<T: Obj>(obj: T) -> Ptr<T> {
    Ptr::new(GcCell::new(obj))
}

////////////////////////////////////////////////////////////////////////////////
// Obj
////////////////////////////////////////////////////////////////////////////////

pub trait Obj: Debug + Display + Any + Trace {
    fn instantiate(&mut self, ty: ObjP);

    fn is_instantiated(&self) -> bool;
    fn attrs(&self) -> &Attrs;
    fn attrs_mut(&mut self) -> &mut Attrs;

    fn set_attr(&mut self, name: &str, value: ObjP) {
        self.attrs_mut().insert(name.to_string(), value);
    }

    fn get_attr(&self, name: &str) -> Option<ObjP> {
        self.attrs().get(name).map(Ptr::clone)
    }

    fn type_inst(&self) -> ObjP {
        self.get_attr("__type__").unwrap()
    }

    fn type_name(&self) -> Rc<String> {
        with_obj_downcast(self.type_inst(), |type_inst: &TypeInst| {
            Rc::clone(&type_inst.name)
        })
    }

    fn arity(&self) -> Option<Argc> {
        None
    }

    fn call(&self, vm: &mut Vm, argc: Argc) {
        // TODO Obj::call - need to handle "this object cannot be called" errors
        // BLOCKED-ON: exceptions
        todo!("Raise some kind of not implemented/not callable error for non-callable objects")
    }

    fn is_truthy(&self) -> bool {
        true
    }

    fn equals(&self, other: &dyn Obj) -> bool;

    fn as_any(&self) -> &dyn Any;

    fn as_any_mut(&mut self) -> &mut dyn Any;
}

////////////////////////////////////////////////////////////////////////////////
// BaseObjInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Default, Trace)]
struct BaseObjInst {
    attrs: Attrs,
    is_instantiated: bool,
}

impl Finalize for BaseObjInst {
    fn finalize(&self) {}
}

impl Clone for BaseObjInst {
    fn clone(&self) -> Self {
        Self {
            attrs: self.attrs.clone(),
            is_instantiated: self.is_instantiated,
        }
    }
}

impl Display for BaseObjInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "<BaseObjInst at {:x}>", (self as *const _ as usize))
    }
}

impl Obj for BaseObjInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.set_attr("__type__", ty);

        // TODO BaseObjInst::instantiate - instantiate VTable
        // Okay, we are running into a little snag here:
        // * TypeInst::vtable holds a collection of named objects that will get copied into the
        //   attributes during instatiation.
        // * If an object that gets copied is a function (UserFunctionInst, BuiltinFunctionInst),
        //   it will be wrapped by a MethodInst
        // * MethodInst requires a pointer to the function being wrapped, as well as a pointer to
        //   the "self" object.
        // * This is the root of the problem - ***we need the pointer to the object that we are
        //   currently instantiating.***
        /*
        let type_inst_ptr = Ptr::clone(&self.type_inst());
        with_obj_downcast(type_inst_ptr, |type_inst: &TypeInst| {
            for (key, value_ptr) in type_inst.vtable.iter() {
                // copy functions over as MethodInst
                if obj_is_inst::<BuiltinFunctionInst>(&value_ptr)
                    || obj_is_inst::<UserFunctionInst>(&value_ptr)
                {
                    self.set_attr(key, MethodInst::create(value_ptr));
                }
            }
        });
        */

        self.is_instantiated = true;
    }

    fn is_instantiated(&self) -> bool {
        self.is_instantiated
    }

    fn attrs(&self) -> &Attrs {
        &self.attrs
    }

    fn attrs_mut(&mut self) -> &mut Attrs {
        &mut self.attrs
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<BaseObjInst>() {
            // compare all attrs
            self.attrs.iter().all(|(k1, v1)| {
                other
                    .attrs
                    .get(k1)
                    .map(|v2| v2.borrow().equals(&*v1.borrow()))
                    .unwrap_or(false)
            }) && self.is_instantiated == other.is_instantiated
        } else {
            false
        }
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn Any {
        self
    }
}

macro_rules! impl_base_obj {
    ($base_name:ident) => {
        fn is_instantiated(&self) -> bool {
            self.$base_name.is_instantiated()
        }

        fn attrs(&self) -> &Attrs {
            self.$base_name.attrs()
        }

        fn attrs_mut(&mut self) -> &mut Attrs {
            self.$base_name.attrs_mut()
        }

        fn as_any(&self) -> &dyn Any {
            self
        }

        fn as_any_mut(&mut self) -> &mut dyn Any {
            self
        }
    };
    () => {
        impl_base_obj! { base }
    };
}

////////////////////////////////////////////////////////////////////////////////
// ObjInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Trace)]
pub struct ObjInst {
    base: BaseObjInst,
}

impl ObjInst {
    pub fn new() -> Self {
        Self {
            base: Default::default(),
        }
    }

    pub fn create(ty: ObjP) -> Ptr<Self> {
        let mut new = Self::new();
        new.instantiate(ty);
        make_ptr(new)
    }
}

impl Finalize for ObjInst {
    fn finalize(&self) {}
}

impl Display for ObjInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "<ObjInst at {:x}>", (self as *const _ as usize))
    }
}

impl Obj for ObjInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<ObjInst>() {
            self.base.equals(&other.base)
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// TypeInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Trace)]
pub struct TypeInst {
    #[unsafe_ignore_trace]
    name: Rc<String>,
    base: BaseObjInst,
    vtable: HashMap<String, ObjP>,
}

impl Finalize for TypeInst {
    fn finalize(&self) {}
}

impl TypeInst {
    pub fn new(name: impl ToString) -> Self {
        Self {
            name: Rc::new(name.to_string()),
            base: Default::default(),
            vtable: Default::default(),
        }
    }

    pub fn create(ty: ObjP, name: impl ToString) -> Ptr<Self> {
        let mut new = Self::new(name);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn name(&self) -> &Rc<String> {
        &self.name
    }
}

impl Debug for TypeInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "<Type {} at {:x}>",
            self.name,
            (self as *const _ as usize)
        )
    }
}

impl Display for TypeInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "<Type {} at {:x}>",
            self.name,
            (self as *const _ as usize)
        )
    }
}

impl Obj for TypeInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<TypeInst>() {
            // TODO TypeInst::equals : something more robust than this
            // Types should hold equality if they have the same name
            // the problem is that Type.get_attr("__type__") is going to return itself, so we have
            // to go through attributes to specially exclude to the __type__ attribute if it points
            // to ourself.
            // How do we detect that it's pointing to ourself? I suppose pointers are the way
            self.name == other.name
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// StrInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Trace)]
pub struct StrInst {
    #[unsafe_ignore_trace]
    str_value: Rc<String>,
    base: BaseObjInst,
}

impl StrInst {
    pub fn new(str_value: impl ToString) -> Self {
        Self {
            str_value: Rc::new(str_value.to_string()),
            base: Default::default(),
        }
    }

    pub fn create(ty: ObjP, str_value: impl ToString) -> Ptr<Self> {
        let mut new = Self::new(str_value);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn str_value(&self) -> &Rc<String> {
        &self.str_value
    }
}

impl Finalize for StrInst {
    fn finalize(&self) {}
}

impl Display for StrInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}", self.str_value)
    }
}

impl Obj for StrInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn is_truthy(&self) -> bool {
        !self.str_value.is_empty()
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<StrInst>() {
            self.str_value == other.str_value
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// IntInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Trace)]
pub struct IntInst {
    int_value: i64,
    base: BaseObjInst,
}

impl IntInst {
    pub fn new(int_value: i64) -> Self {
        Self {
            int_value,
            base: Default::default(),
        }
    }

    pub fn create(ty: ObjP, int_value: i64) -> Ptr<Self> {
        let mut new = Self::new(int_value);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn int_value(&self) -> i64 {
        self.int_value
    }
}

impl Finalize for IntInst {
    fn finalize(&self) {}
}

impl Display for IntInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}", self.int_value)
    }
}

impl Obj for IntInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn is_truthy(&self) -> bool {
        self.int_value != 0
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<IntInst>() {
            self.int_value == other.int_value
        } else if let Some(other) = other.as_any().downcast_ref::<FloatInst>() {
            self.int_value as f64 == other.float_value
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// FloatInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Trace)]
pub struct FloatInst {
    float_value: f64,
    base: BaseObjInst,
}

impl FloatInst {
    pub fn new(float_value: f64) -> Self {
        Self {
            float_value,
            base: Default::default(),
        }
    }

    pub fn create(ty: ObjP, float_value: f64) -> Ptr<Self> {
        let mut new = Self::new(float_value);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn float_value(&self) -> f64 {
        self.float_value
    }
}

impl Finalize for FloatInst {
    fn finalize(&self) {}
}

impl Display for FloatInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}", self.float_value)
    }
}

impl Obj for FloatInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn is_truthy(&self) -> bool {
        self.float_value != 0.0
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<FloatInst>() {
            self.float_value == other.float_value
        } else if let Some(other) = other.as_any().downcast_ref::<IntInst>() {
            self.float_value == other.int_value as f64
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// BoolInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Trace)]
pub struct BoolInst {
    bool_value: bool,
    base: BaseObjInst,
}

impl BoolInst {
    pub fn new(bool_value: bool) -> Self {
        Self {
            bool_value,
            base: Default::default(),
        }
    }

    pub fn create(ty: ObjP, bool_value: bool) -> Ptr<Self> {
        // TODO BoolInst::create : interning
        let mut new = Self::new(bool_value);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn bool_value(&self) -> bool {
        self.bool_value
    }
}

impl Finalize for BoolInst {
    fn finalize(&self) {}
}

impl Display for BoolInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}", self.bool_value)
    }
}

impl Obj for BoolInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn is_truthy(&self) -> bool {
        self.bool_value
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<BoolInst>() {
            self.bool_value == other.bool_value
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// NilInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Default, Trace)]
pub struct NilInst {
    base: BaseObjInst,
}

impl NilInst {
    pub fn new() -> Self {
        Default::default()
    }

    pub fn create(ty: ObjP) -> Ptr<Self> {
        // TODO NilInst::create : interning
        let mut new = Self::new();
        new.instantiate(ty);
        make_ptr(new)
    }
}

impl Finalize for NilInst {
    fn finalize(&self) {}
}

impl Display for NilInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "nil")
    }
}

impl Obj for NilInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn is_truthy(&self) -> bool {
        false
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        other.as_any().downcast_ref::<NilInst>().is_some()
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// BuiltinFunctionInst
////////////////////////////////////////////////////////////////////////////////

pub type BuiltinFunctionPtr = fn(vm: &mut Vm, args: Vec<ObjP>) -> ObjP;

#[derive(Debug, Trace)]
pub struct BuiltinFunctionInst {
    base: BaseObjInst,
    name: String,
    #[unsafe_ignore_trace]
    function: BuiltinFunctionPtr,
    arity: Argc,
}

impl BuiltinFunctionInst {
    pub fn new(name: impl ToString, function: BuiltinFunctionPtr, arity: Argc) -> Self {
        Self {
            base: Default::default(),
            name: name.to_string(),
            function,
            arity,
        }
    }

    pub fn create(
        ty: ObjP,
        name: impl ToString,
        function: BuiltinFunctionPtr,
        arity: Argc,
    ) -> Ptr<Self> {
        let mut new = Self::new(name, function, arity);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn name(&self) -> &String {
        &self.name
    }
}

impl Finalize for BuiltinFunctionInst {
    fn finalize(&self) {}
}

impl Display for BuiltinFunctionInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "<BuiltinFunction {}/{} at 0x{:x}>",
            self.name(),
            self.arity().unwrap(),
            self.function as *const BuiltinFunctionPtr as usize
        )
    }
}

impl Obj for BuiltinFunctionInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn arity(&self) -> Option<Argc> {
        Some(self.arity)
    }

    fn call(&self, vm: &mut Vm, argc: Argc) {
        // args
        let mut args = Vec::with_capacity(argc as usize);
        for _ in 0..argc {
            args.push(vm.pop());
        }
        args.reverse();
        // callee (self)
        vm.pop();
        let result = (self.function)(vm, args);
        vm.push(result);
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        // TODO BuiltinFunctionInst::equals : need something more robust than checking addr_eq,
        // maybe check the self_binding pointer too?
        if let Some(other) = other.as_any().downcast_ref::<BuiltinFunctionInst>() {
            ptr::addr_eq(self, other)
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// UserFunctionInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Clone, Trace)]
pub struct UserFunctionInst {
    base: BaseObjInst,
    #[unsafe_ignore_trace]
    name: Rc<String>,
    #[unsafe_ignore_trace]
    chunk: Rc<Chunk>,
    arity: Argc,
    captures: Vec<ObjP>,
}

impl UserFunctionInst {
    pub fn new(chunk: Chunk, arity: Argc) -> Self {
        Self {
            base: Default::default(),
            name: Rc::new("(anonymous)".to_string()),
            chunk: Rc::new(chunk),
            arity,
            captures: Default::default(),
        }
    }

    pub fn create(ty: ObjP, chunk: Chunk, arity: Argc) -> Ptr<Self> {
        let mut new = Self::new(chunk, arity);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn name(&self) -> &String {
        &self.name
    }

    pub fn set_name(&mut self, name: Rc<String>) {
        self.name = name;
    }

    pub fn chunk(&self) -> &Chunk {
        &self.chunk
    }

    pub fn push_capture(&mut self, value: ObjP) {
        self.captures.push(value);
    }
}

impl Finalize for UserFunctionInst {
    fn finalize(&self) {}
}

impl Display for UserFunctionInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(
            fmt,
            "<UserFunction {}/{} at 0x{:x}>",
            self.name(),
            self.arity().unwrap(),
            self as *const _ as usize
        )
    }
}

impl Obj for UserFunctionInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn arity(&self) -> Option<Argc> {
        Some(self.arity)
    }

    fn call(&self, vm: &mut Vm, argc: Argc) {
        assert_eq!(argc, self.arity, "argc must match arity");
        let new_frame = Frame {
            name: Rc::clone(&self.name),
            chunk: Rc::clone(&self.chunk),
            ip: 0,
            stack_base: vm.stack().len() - (argc as usize),
        };
        vm.push_frame(new_frame);
        for capture in &self.captures {
            vm.push(Ptr::clone(&capture));
        }
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<UserFunctionInst>() {
            // TODO UserFunctionInst::equals : need something more robust than checking addr_eq.
            ptr::addr_eq(self, other)
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// MethodInst
////////////////////////////////////////////////////////////////////////////////

#[derive(Debug, Trace)]
pub struct MethodInst {
    base: BaseObjInst,
    self_binding: ObjP,
    function: ObjP,
}

impl MethodInst {
    pub fn new(self_binding: ObjP, function: ObjP) -> Self {
        Self {
            base: Default::default(),
            self_binding,
            function,
        }
    }

    pub fn create(ty: ObjP, self_binding: ObjP, function: ObjP) -> Ptr<Self> {
        let mut new = Self::new(self_binding, function);
        new.instantiate(ty);
        make_ptr(new)
    }

    pub fn self_binding(&self) -> &ObjP {
        &self.self_binding
    }
}

impl Finalize for MethodInst {
    fn finalize(&self) {}
}

impl Display for MethodInst {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}", self.function.borrow())
    }
}

impl Obj for MethodInst {
    fn instantiate(&mut self, ty: ObjP) {
        self.base.instantiate(ty);
    }

    fn arity(&self) -> Option<Argc> {
        self.function.borrow().arity()
    }

    fn call(&self, vm: &mut Vm, argc: Argc) {
        self.function.borrow().call(vm, argc)
    }

    fn equals(&self, other: &dyn Obj) -> bool {
        if let Some(other) = other.as_any().downcast_ref::<MethodInst>() {
            ptr::addr_eq(&*self.self_binding, &*other.self_binding)
                && ptr::addr_eq(&*self.function, &*other.function)
        } else {
            false
        }
    }

    impl_base_obj!();
}

////////////////////////////////////////////////////////////////////////////////
// Tests
////////////////////////////////////////////////////////////////////////////////

#[test]
fn test_new_objects() {
    let mut builtins = HashMap::new();
    init_types(&mut builtins);

    let type_value = builtins.create_type("Type");
    assert_eq!(&*type_value.borrow().type_name(), "Type");

    let str_value = builtins.create_str("asdfasdfasdfasdfasdf");
    assert_eq!(&*str_value.borrow().type_name(), "Str");

    let int_value = builtins.create_int(1234);
    assert_eq!(&*int_value.borrow().type_name(), "Int");

    let float_value = builtins.create_float(1234.5678);
    assert_eq!(&*float_value.borrow().type_name(), "Float");

    let nil_value = builtins.create_nil();
    assert_eq!(&*nil_value.borrow().type_name(), "Nil");
}

#[test]
fn test_obj_equals() {
    let mut builtins = HashMap::new();
    init_types(&mut builtins);

    let int1 = builtins.create_int(1234);
    let int2 = builtins.create_int(1234);

    assert!(int1.borrow().equals(&*int2.borrow()));
    assert!(int2.borrow().equals(&*int1.borrow()));

    let float1 = builtins.create_float(1234.0);
    assert!(int1.borrow().equals(&*float1.borrow()));
    assert!(float1.borrow().equals(&*int2.borrow()));

    // self-equality
    let str1 = builtins.create_str("1234");
    assert!(str1.borrow().equals(&*str1.borrow()));

    let str2 = builtins.create_str("1234");
    assert!(str1.borrow().equals(&*str2.borrow()));
    assert!(str2.borrow().equals(&*str1.borrow()));

    assert!(!str1.borrow().equals(&*float1.borrow()));
    assert!(!str1.borrow().equals(&*int1.borrow()));

    let obj1 = builtins.create_obj();
    let obj2 = builtins.create_obj();
    assert!(obj1.borrow().equals(&*obj2.borrow()));

    // these objects aren't equal anymore
    obj1.borrow_mut().set_attr("my_attr", ObjP::clone(&str2));
    assert!(!obj1.borrow().equals(&*obj2.borrow()));

    // but now they are!
    obj2.borrow_mut().set_attr("my_attr", ObjP::clone(&str2));
    assert!(obj2.borrow().equals(&*obj1.borrow()));
}