Chore: Use a binary table to search using O(log n) for attr.

Author: dylan-sutton-chavez

compiler/src/modules/vm/handlers/attr.rs

@@ -1,68 +1,75 @@
-// vm/handlers/attr.rs
-
 use super::*;
 use crate::modules::vm::types::BuiltinMethodId;
 
+type AttrRow = (&'static str, &'static str, BuiltinMethodId);
+
+// Table of built-in methods organized by (type, attribute_name). It must be kept in lexicographical order to allow binary search.
+static ATTR_TABLE: &[AttrRow] = &[
+    ("dict", "get", BuiltinMethodId::DictGet),
+    ("dict", "items", BuiltinMethodId::DictItems),
+    ("dict", "keys", BuiltinMethodId::DictKeys),
+    ("dict", "pop", BuiltinMethodId::DictPop),
+    ("dict", "setdefault", BuiltinMethodId::DictSetDefault),
+    ("dict", "update", BuiltinMethodId::DictUpdate),
+    ("dict", "values", BuiltinMethodId::DictValues),
+    ("list", "append", BuiltinMethodId::ListAppend),
+    ("list", "clear", BuiltinMethodId::ListClear),
+    ("list", "copy", BuiltinMethodId::ListCopy),
+    ("list", "count", BuiltinMethodId::ListCount),
+    ("list", "extend", BuiltinMethodId::ListExtend),
+    ("list", "index", BuiltinMethodId::ListIndex),
+    ("list", "insert", BuiltinMethodId::ListInsert),
+    ("list", "pop", BuiltinMethodId::ListPop),
+    ("list", "remove", BuiltinMethodId::ListRemove),
+    ("list", "reverse", BuiltinMethodId::ListReverse),
+    ("list", "sort", BuiltinMethodId::ListSort),
+    ("str", "capitalize", BuiltinMethodId::StrCapitalize),
+    ("str", "center", BuiltinMethodId::StrCenter),
+    ("str", "count", BuiltinMethodId::StrCount),
+    ("str", "endswith", BuiltinMethodId::StrEndswith),
+    ("str", "find", BuiltinMethodId::StrFind),
+    ("str", "isalnum", BuiltinMethodId::StrIsAlnum),
+    ("str", "isalpha", BuiltinMethodId::StrIsAlpha),
+    ("str", "isdigit", BuiltinMethodId::StrIsDigit),
+    ("str", "join", BuiltinMethodId::StrJoin),
+    ("str", "lower", BuiltinMethodId::StrLower),
+    ("str", "lstrip", BuiltinMethodId::StrLstrip),
+    ("str", "replace", BuiltinMethodId::StrReplace),
+    ("str", "rstrip", BuiltinMethodId::StrRstrip),
+    ("str", "split", BuiltinMethodId::StrSplit),
+    ("str", "startswith", BuiltinMethodId::StrStartswith),
+    ("str", "strip", BuiltinMethodId::StrStrip),
+    ("str", "title", BuiltinMethodId::StrTitle),
+    ("str", "upper", BuiltinMethodId::StrUpper),
+    ("str", "zfill", BuiltinMethodId::StrZfill),
+];
+
+#[inline]
+fn lookup_attr(ty: &str, attr: &str) -> Option<BuiltinMethodId> {
+    ATTR_TABLE.binary_search_by(|&(t, a, _)| { t.cmp(ty).then_with(|| a.cmp(attr))})
+        .ok()
+        .map(|i| ATTR_TABLE[i].2)
+}
+
 impl<'a> VM<'a> {
-    /// Resolves `obj.name` for builtin types. Pops `obj`, pushes a bound
-    /// method or returns Err if the attribute is unknown for the type.
     pub(crate) fn handle_load_attr(&mut self, name_idx: u16, chunk: &SSAChunk) -> Result<(), VmErr> {
-        let name = chunk.names.get(name_idx as usize)
-            .ok_or(VmErr::Runtime("LoadAttr: bad name index"))?;
+        let name = chunk.names.get(name_idx as usize).ok_or(VmErr::Runtime("LoadAttr: bad name index"))?;
+        
         let obj = self.pop()?;
+        let ty = self.type_name(obj);
 
-        let method_id = match (self.type_name(obj), name.as_str()) {
-            ("list", "append")      => BuiltinMethodId::ListAppend,
-            ("dict", "keys")        => BuiltinMethodId::DictKeys,
-            ("dict", "values")      => BuiltinMethodId::DictValues,
-            ("dict", "items")       => BuiltinMethodId::DictItems,
-            ("str", "upper")        => BuiltinMethodId::StrUpper,
-            ("str", "lower")        => BuiltinMethodId::StrLower,
-            ("str", "strip")        => BuiltinMethodId::StrStrip,
-            ("str", "split")        => BuiltinMethodId::StrSplit,
-            ("str", "join")         => BuiltinMethodId::StrJoin,
-            ("str", "replace")      => BuiltinMethodId::StrReplace,
-            ("str", "startswith")   => BuiltinMethodId::StrStartswith,
-            ("str", "endswith")     => BuiltinMethodId::StrEndswith,
-            ("str", "find")         => BuiltinMethodId::StrFind,
-            ("str", "count")        => BuiltinMethodId::StrCount,
-            ("list", "sort")        => BuiltinMethodId::ListSort,
-            ("list", "reverse")     => BuiltinMethodId::ListReverse,
-            ("list", "pop")         => BuiltinMethodId::ListPop,
-            ("list", "insert")      => BuiltinMethodId::ListInsert,
-            ("list", "remove")      => BuiltinMethodId::ListRemove,
-            ("list", "index")       => BuiltinMethodId::ListIndex,
-            ("list", "count")       => BuiltinMethodId::ListCount,
-            ("dict", "get")         => BuiltinMethodId::DictGet,
-            ("dict", "update")      => BuiltinMethodId::DictUpdate,
-            ("dict", "pop")         => BuiltinMethodId::DictPop,
-            ("dict", "setdefault")  => BuiltinMethodId::DictSetDefault,
-            ("str", "lstrip")       => BuiltinMethodId::StrLstrip,
-            ("str", "rstrip")       => BuiltinMethodId::StrRstrip,
-            ("str", "isdigit")      => BuiltinMethodId::StrIsDigit,
-            ("str", "isalpha")      => BuiltinMethodId::StrIsAlpha,
-            ("str", "isalnum")      => BuiltinMethodId::StrIsAlnum,
-            ("str", "capitalize")   => BuiltinMethodId::StrCapitalize,
-            ("str", "title")        => BuiltinMethodId::StrTitle,
-            ("str", "center")       => BuiltinMethodId::StrCenter,
-            ("str", "zfill")        => BuiltinMethodId::StrZfill,
-            ("list", "extend")      => BuiltinMethodId::ListExtend,
-            ("list", "clear")       => BuiltinMethodId::ListClear,
-            ("list", "copy")        => BuiltinMethodId::ListCopy,
-            (ty, attr) => {
-                return Err(attr_not_found(ty, attr));
-            }
-        };
+        // Binary search using O(log n)
+        let method_id = lookup_attr(ty, name.as_str()).ok_or_else(|| attr_not_found(ty, name.as_str()))?;
 
         let bound = self.heap.alloc(HeapObj::BoundMethod(obj, method_id))?;
         self.push(bound);
+        
         Ok(())
     }
 }
 
 #[cold]
 fn attr_not_found(ty: &str, attr: &str) -> VmErr {
-    // Static message keeps VmErr::Type's &'static str contract.
-    let _ = (ty, attr); // params kept for future expansion
+    let _ = (ty, attr); 
     VmErr::Type("'object' has no attribute")
 }