refactor: StringForge 规范化类型命名

crates/oxide_kernel/src/builtin.rs

@@ -3,7 +3,7 @@ use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
 use crate::shape_forge::{ShapeForge, EMPTY_SHAPE_ID};
-use crate::string_forge::Interner;
+use crate::string_forge::StringForge;
 
 pub struct BuiltinWorld {
     pub object_proto: P<JsObject>,
@@ -24,12 +24,12 @@ pub struct BuiltinWorld {
     pub symbol_constructor: P<JsObject>,
 }
 
-fn intern_label(interner: &Interner, label: &str) -> u32 {
-    interner.intern(label).0
+fn intern_label(string_forge: &StringForge, label: &str) -> u32 {
+    string_forge.intern(label).0
 }
 
 fn make_pair(
-    string_forge: &Interner,
+    string_forge: &StringForge,
     shape_forge: &ShapeForge,
     name: &str,
     si_prototype: u32,
@@ -59,7 +59,7 @@ fn make_pair(
 }
 
 impl BuiltinWorld {
-    pub fn new(string_forge: &Interner, shape_forge: &ShapeForge) -> Self {
+    pub fn new(string_forge: &StringForge, shape_forge: &ShapeForge) -> Self {
         let si_prototype = intern_label(string_forge, "prototype");
         let si_constructor = intern_label(string_forge, "constructor");
         let si_name = intern_label(string_forge, "name");
@@ -157,10 +157,10 @@ impl BuiltinWorld {
 mod tests {
     use super::*;
     use crate::shape_forge::{ShapeForge, EMPTY_SHAPE_ID};
-    use crate::string_forge::Interner;
+    use crate::string_forge::StringForge;
 
     fn make_world() -> BuiltinWorld {
-        let sf = Interner::new();
+        let sf = StringForge::new();
         let sh = ShapeForge::new();
         BuiltinWorld::new(&sf, &sh)
     }

crates/oxide_kernel/src/kernel.rs

@@ -6,7 +6,7 @@ use crate::builtin::BuiltinWorld;
 use crate::code_forge::CodeForge;
 use crate::prop_forge::PropForge;
 use crate::shape_forge::ShapeForge;
-use crate::string_forge::Interner;
+use crate::string_forge::StringForge;
 
 pub struct KernelConfig {
     pub min_pool_size: usize,
@@ -60,7 +60,7 @@ impl Default for KernelConfig {
 
 pub struct OxideKernel {
     pub config: KernelConfig,
-    pub string_forge: Arc<Interner>,
+    pub string_forge: Arc<StringForge>,
     pub shape_forge: Arc<ShapeForge>,
     pub code_forge: Arc<CodeForge>,
     pub prop_forge: Arc<PropForge>,
@@ -69,7 +69,7 @@ pub struct OxideKernel {
 
 impl OxideKernel {
     pub fn new(config: KernelConfig) -> Self {
-        let string_forge = Arc::new(Interner::new());
+        let string_forge = Arc::new(StringForge::new());
         let shape_forge = Arc::new(ShapeForge::new());
         let builtin_world = Arc::new(BuiltinWorld::new(&string_forge, &shape_forge));
         let code_forge = Arc::new(CodeForge::new());
@@ -85,7 +85,7 @@ impl OxideKernel {
         }
     }
 
-    pub fn string_forge(&self) -> &Arc<Interner> {
+    pub fn string_forge(&self) -> &Arc<StringForge> {
         &self.string_forge
     }
 

crates/oxide_kernel/src/string_forge.rs

@@ -17,19 +17,19 @@ pub struct StringEntry {
     pub hash: u16,
 }
 
-struct InternerInner {
+struct StringForgeInner {
     map: HashMap<String, u32, FxBuildHasher>,
     entries: Vec<StringEntry>,
 }
 
-pub struct Interner {
-    inner: RwLock<InternerInner>,
+pub struct StringForge {
+    inner: RwLock<StringForgeInner>,
 }
 
-impl Interner {
+impl StringForge {
     pub fn new() -> Self {
         Self {
-            inner: RwLock::new(InternerInner {
+            inner: RwLock::new(StringForgeInner {
                 map: HashMap::with_hasher(FxBuildHasher::default()),
                 entries: Vec::new(),
             }),
@@ -111,7 +111,7 @@ impl Interner {
     }
 }
 
-impl Default for Interner {
+impl Default for StringForge {
     fn default() -> Self {
         Self::new()
     }
@@ -133,56 +133,56 @@ mod tests {
 
     #[test]
     fn test_intern_dedup() {
-        let interner = Interner::new();
-        let (i1, h1) = interner.intern("abc");
-        let (i2, h2) = interner.intern("abc");
+        let string_forge = StringForge::new();
+        let (i1, h1) = string_forge.intern("abc");
+        let (i2, h2) = string_forge.intern("abc");
         assert_eq!(i1, i2);
         assert_eq!(h1, h2);
     }
 
     #[test]
     fn test_intern_different() {
-        let interner = Interner::new();
-        let (i1, _) = interner.intern("x");
-        let (i2, _) = interner.intern("y");
+        let string_forge = StringForge::new();
+        let (i1, _) = string_forge.intern("x");
+        let (i2, _) = string_forge.intern("y");
         assert_ne!(i1, i2);
     }
 
     #[test]
     fn test_lookup_found() {
-        let interner = Interner::new();
-        let (idx, _) = interner.intern("hello");
-        assert_eq!(interner.lookup(idx), Some("hello".to_string()));
+        let string_forge = StringForge::new();
+        let (idx, _) = string_forge.intern("hello");
+        assert_eq!(string_forge.lookup(idx), Some("hello".to_string()));
     }
 
     #[test]
     fn test_lookup_not_found() {
-        let interner = Interner::new();
-        assert_eq!(interner.lookup(99999), None);
+        let string_forge = StringForge::new();
+        assert_eq!(string_forge.lookup(99999), None);
     }
 
     #[test]
     fn test_ref_count_and_decref() {
-        let interner = Interner::new();
-        let (idx, _) = interner.intern("s");
-        assert_eq!(interner.lookup(idx), Some("s".to_string()));
-        interner.decref(idx);
-        assert_eq!(interner.lookup(idx), Some("s".to_string()));
+        let string_forge = StringForge::new();
+        let (idx, _) = string_forge.intern("s");
+        assert_eq!(string_forge.lookup(idx), Some("s".to_string()));
+        string_forge.decref(idx);
+        assert_eq!(string_forge.lookup(idx), Some("s".to_string()));
     }
 
     #[test]
     fn test_maybe_sweep_noop_when_none() {
-        let interner = Interner::new();
-        interner.intern("live");
-        interner.maybe_sweep(None);
-        assert!(interner.lookup(0).is_some());
+        let string_forge = StringForge::new();
+        string_forge.intern("live");
+        string_forge.maybe_sweep(None);
+        assert!(string_forge.lookup(0).is_some());
     }
 
     #[test]
     fn test_maybe_sweep_skip_below_threshold() {
-        let interner = Interner::new();
-        interner.intern("live");
-        interner.maybe_sweep(Some(100));
-        assert_eq!(interner.lookup(0), Some("live".to_string()));
+        let string_forge = StringForge::new();
+        string_forge.intern("live");
+        string_forge.maybe_sweep(Some(100));
+        assert_eq!(string_forge.lookup(0), Some("live".to_string()));
     }
 }