Implement RSScript v0.5 lowering groundwork

Author: olwang

.gitignore

@@ -1,2 +1,4 @@
 /target/
+tests/generated/**/target/
+tests/generated/**/Cargo.lock
 .DS_Store

Cargo.lock

@@ -2,9 +2,12 @@
 name = "rsscript"
 version = "0.1.0"
 edition = "2024"
-description = "RSScript v0.4.1 front-end checker"
+description = "RSScript v0.5 review-first front-end checker and Rust lowering prototype"
 license = "MIT"
 
+[workspace]
+members = ["runtime"]
+
 [[bin]]
 name = "rss"
 path = "src/main.rs"

Cargo.toml

@@ -556,6 +556,7 @@ The intended workflow is:
 rss check
 rss fmt
 rss review
+rss lower --rust
 rss test
 ```
 
@@ -590,12 +591,12 @@ Planned stages:
 2. Real AST parser
 3. HIR and symbol table
 4. Semantic checker
-5. Managed interpreter
-6. Resource runtime
-7. Local / fresh / manage runtime
-8. Core library MVP
-9. Semantic review tooling
-10. Runnable MVP
+5. Rust lowering shape contract
+6. Runtime crate type surface
+7. Rust source generation with source maps
+8. rustc diagnostic mapping
+9. Core library signatures
+10. Runnable MVP through rustc
 ```
 
 The project will grow by testing the language against real scenarios:

README.md

@@ -0,0 +1,12 @@
+[package]
+name = "rsscript-runtime"
+version = "0.1.0"
+edition = "2024"
+description = "Runtime hooks for RSScript Rust lowering"
+license = "MIT"
+
+[lib]
+name = "rsscript_runtime"
+path = "src/lib.rs"
+
+[dependencies]

runtime/Cargo.toml

@@ -0,0 +1,133 @@
+use std::cell::{RefCell, RefMut};
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+
+pub trait Managed {}
+
+impl<T: 'static> Managed for T {}
+
+pub trait Resource {}
+
+#[derive(Clone)]
+pub struct Gc<T> {
+    inner: Rc<T>,
+}
+
+impl<T> Gc<T> {
+    pub fn new(value: T) -> Self {
+        Self {
+            inner: Rc::new(value),
+        }
+    }
+
+    pub fn get(&self) -> &T {
+        &self.inner
+    }
+
+    pub fn ptr_eq(left: &Self, right: &Self) -> bool {
+        Rc::ptr_eq(&left.inner, &right.inner)
+    }
+}
+
+impl<T> Deref for Gc<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.get()
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Gc<T> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.debug_tuple("Gc").field(&self.inner).finish()
+    }
+}
+
+pub fn manage<T>(value: T) -> Gc<T> {
+    Gc::new(value)
+}
+
+#[derive(Debug)]
+pub struct ResourcePool<T: Resource> {
+    values: RefCell<Vec<T>>,
+}
+
+impl<T: Resource> ResourcePool<T> {
+    pub fn new(values: Vec<T>) -> Self {
+        Self {
+            values: RefCell::new(values),
+        }
+    }
+
+    pub fn empty() -> Self {
+        Self::new(Vec::new())
+    }
+
+    pub fn push(&self, value: T) {
+        self.values.borrow_mut().push(value);
+    }
+
+    pub fn borrow(&self) -> ResourceLease<'_, T> {
+        ResourceLease {
+            values: self.values.borrow_mut(),
+            index: 0,
+        }
+    }
+}
+
+pub struct ResourceLease<'a, T: Resource> {
+    values: RefMut<'a, Vec<T>>,
+    index: usize,
+}
+
+impl<T: Resource> Deref for ResourceLease<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.values[self.index]
+    }
+}
+
+impl<T: Resource> DerefMut for ResourceLease<'_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.values[self.index]
+    }
+}
+
+impl<T: Resource> fmt::Debug for ResourceLease<'_, T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_tuple("ResourceLease")
+            .field(&self.values[self.index])
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Resource, ResourcePool, manage};
+
+    #[derive(Debug)]
+    struct FileHandle(i32);
+
+    impl Resource for FileHandle {}
+
+    #[test]
+    fn manage_wraps_value_in_gc_handle() {
+        let value = manage(String::from("cached"));
+
+        assert_eq!(value.get(), "cached");
+    }
+
+    #[test]
+    fn resource_pool_borrows_scoped_resource() {
+        let pool = ResourcePool::new(vec![FileHandle(7)]);
+        let lease = pool.borrow();
+
+        assert_eq!(lease.0, 7);
+    }
+}