module: Remove a duplicate field from UnboundValue

Summary:
This is already stored in the `NativeMethod`

This adds a pointer indirection to this call, but not a virtual call, so it should be fine. In any case, it'll be gone again next diff

Reviewed By: Nero5023

Differential Revision: D73726007

fbshipit-source-id: dbba4073bc01626d6afceed61c6831c129cd5216

Author: JakobDegen

starlark/src/environment/methods.rs

@@ -30,7 +30,6 @@ use crate::values::FrozenHeap;
 use crate::values::FrozenHeapRef;
 use crate::values::FrozenRef;
 use crate::values::FrozenValue;
-use crate::values::FrozenValueTyped;
 use crate::values::Heap;
 use crate::values::Value;
 use crate::values::function::NativeAttribute;
@@ -75,7 +74,7 @@ impl Methods {
     pub(crate) fn get_ty(&self, name: &str) -> Option<Ty> {
         match self.members.get_str(name)? {
             UnboundValue::Attr(attr) => Some(attr.typ.dupe()),
-            UnboundValue::Method(method, _) => Some(method.ty.dupe()),
+            UnboundValue::Method(method) => Some(method.ty.dupe()),
         }
     }
 
@@ -220,17 +219,13 @@ impl MethodsBuilder {
         );
         self.members.insert(
             name,
-            UnboundValue::Method(
-                FrozenValueTyped::new(self.heap.alloc(NativeMethod {
-                    function,
-                    name: name.to_owned(),
-                    speculative_exec_safe: components.speculative_exec_safe,
-                    docs: components.into_docs(None),
-                    ty,
-                }))
-                .unwrap(),
+            UnboundValue::Method(self.heap.alloc_simple_typed(NativeMethod {
                 function,
-            ),
+                name: name.to_owned(),
+                speculative_exec_safe: components.speculative_exec_safe,
+                docs: components.into_docs(None),
+                ty,
+            })),
         );
     }
 

starlark/src/eval/compiler/expr.rs

@@ -873,7 +873,7 @@ impl ExprCompiled {
         let v = get_attr_hashed_raw(left.to_value(), attr, ctx.heap()).ok()?;
         match v {
             MemberOrValue::Member(m) => match m {
-                UnboundValue::Method(m, _) => Some(
+                UnboundValue::Method(m) => Some(
                     ctx.frozen_heap()
                         .alloc_simple(BoundMethodGen::new(left, *m)),
                 ),

starlark/src/values/types/unbound.rs

@@ -32,17 +32,13 @@ use crate::values::Value;
 use crate::values::ValueLike;
 use crate::values::function::BoundMethodGen;
 use crate::values::function::NativeAttribute;
-use crate::values::function::NativeMeth;
 use crate::values::function::NativeMethod;
 
 /// A value or an unbound method or unbound attribute.
 #[derive(Clone)]
 pub(crate) enum UnboundValue {
     /// A method with `this` unbound.
-    Method(
-        FrozenValueTyped<'static, NativeMethod>,
-        FrozenRef<'static, dyn NativeMeth>,
-    ),
+    Method(FrozenValueTyped<'static, NativeMethod>),
     /// An attribute with `this` unbound.
     Attr(FrozenValueTyped<'static, NativeAttribute>),
 }
@@ -57,7 +53,7 @@ impl UnboundValue {
     #[inline]
     pub(crate) fn to_frozen_value(&self) -> FrozenValue {
         match self {
-            UnboundValue::Method(m, _) => m.to_frozen_value(),
+            UnboundValue::Method(m) => m.to_frozen_value(),
             UnboundValue::Attr(a) => a.to_frozen_value(),
         }
     }
@@ -66,7 +62,7 @@ impl UnboundValue {
     #[inline]
     pub(crate) fn bind<'v>(&self, this: Value<'v>, heap: &'v Heap) -> crate::Result<Value<'v>> {
         match self {
-            UnboundValue::Method(m, _) => {
+            UnboundValue::Method(m) => {
                 Ok(heap.alloc_complex(BoundMethodGen::new(this.to_value(), *m)))
             }
             UnboundValue::Attr(a) => a.invoke(this, heap),
@@ -85,7 +81,7 @@ impl UnboundValue {
             self.to_frozen_value().to_value(),
             Some(span),
             |eval| match self {
-                UnboundValue::Method(_, m) => m.invoke(eval, this, args),
+                UnboundValue::Method(m) => m.function.invoke(eval, this, args),
                 UnboundValue::Attr(a) => a.invoke(this, eval.heap()),
             },
         )