new update

Author: ahqsoftwares

interpreter/r.rs

@@ -452,7 +452,8 @@ mod ipreter {
                         }),
                         content,
                         &mut app,
-                        &mut app2.heap,
+                        // SAFETY: It'll always unwrap
+                        &mut app2.heap.as_mut().unwrap(),
                         &mut line,
                         &mut markers,
                         false,

interpreter/src/ipreter.rs

@@ -46,7 +46,7 @@ pub fn interpret<'a>(file: &str, mut app: &mut Application<'a>) {
           format!("{}:{}", &file_name, line + 1),
           content,
           &mut app,
-          &mut app2.heap,
+          app2.heap.as_mut().unwrap(),
           &mut line,
           &mut markers,
           false,
@@ -199,11 +199,7 @@ pub(crate) unsafe fn tok_parse<'a>(
       r#async,
     ) {
       None => {
-        if &caller != &"" {
-          error(&format!("Unexpected `{}`", &caller), &file);
-        }
-
-        None
+        error(&format!("Unexpected `{}`", &caller), &file);
       }
       Some(Output::String(v)) => {
         let runt = opt.rem_r_runtime();

interpreter/src/lib.rs

@@ -5,7 +5,7 @@
 #![feature(get_mut_unchecked)]
 
 use std::{
-  collections::HashMap, mem::zeroed, process, sync::LazyLock, time::{Duration, Instant}
+  collections::HashMap, process, sync::LazyLock, time::{Duration, Instant}
 };
 
 pub use paste::paste;
@@ -74,7 +74,7 @@ pub struct Application<'a> {
   code: HashMap<String, String>,
   pub(crate) pkg: LanguagePackages<'a>,
   entry: &'a str,
-  heap: Heap,
+  heap: Option<Heap>,
 
   // Resolve files
   module_resolver: Box<dyn FnMut(&str) -> Vec<u8>>,
@@ -107,10 +107,7 @@ impl<'a> Application<'a> {
     Self {
       code,
       pkg: LanguagePackages::new(),
-      // SAFETY: It is Initialized before being used
-      // Basically its me being lazy & Wanting to reduce computation time
-      #[allow(invalid_value)]
-      heap: unsafe { zeroed() },
+      heap: None,
       entry: &file,
       module_resolver: Box::new(fs_resolver),
       pkg_resolver: Box::new(dll_resolver),
@@ -174,7 +171,7 @@ impl<'a> Application<'a> {
   }
 
   pub fn run(mut self, time: bool) -> ! {
-    self.heap = Heap::new(self.pkg.extends.clone());
+    self.heap = Some(Heap::new(self.pkg.extends.clone()));
     let dur = self.run_non();
 
     if time {

interpreter/src/types/heap.rs

@@ -59,7 +59,7 @@ pub fn call_runtime_val<'a>(
 
   let (ai, bi) = match ptr.get_mut(key)? {
     BufValue::RuntimeRaw(ai, bi) => (ai, bi),
-    val => return handle_runtime(app, val, caller, v, a, c, o),
+    val => return handle_runtime(unsafe { &mut *hp }, val, caller, v, a, c, o),
   };
 
   let data = (ai, bi);
@@ -148,6 +148,14 @@ impl Heap {
     }
   }
 
+  pub(crate) fn get_extends(&self) -> &ExtendsInternal {
+    &self.extends
+  }
+
+  pub(crate) fn get_extends_arc(&self) -> &Arc<ExtendsInternal> {
+    &self.def_extends
+  }
+
   pub fn clear(&mut self) {
     *self = Self::new(self.def_extends.clone());
   }

interpreter/src/types/mod.rs

@@ -19,7 +19,7 @@ pub use heap::*;
 pub use heap_wrap::*;
 use tokio::sync::mpsc::UnboundedReceiver;
 
-use crate::{runtime::RuntimeValue, Application};
+use crate::runtime::RuntimeValue;
 
 pub struct RetBufValue(pub BufValue);
 
@@ -128,26 +128,30 @@ macro_rules! extends {
       }
 
       pub(crate) fn handle_runtime<'a>(
-        app: *mut Application,
+        heap: &mut Heap,
         val: &mut BufValue,
         caller: &'a str,
         v: &'a [*const str],
         a: HeapWrapper,
         c: &String,
         o: &'a mut Options,
       ) -> Option<Output> {
-        let app = unsafe { &mut *app };
-
-        let extends = &app.pkg.extends;
+        let ar = heap.get_extends_arc();
+        let ext = heap.get_extends();
 
         crate::paste! {
           match val {
             $(
               BufValue::[<$good>](data) => {
-                let scope = &extends.$x;
-
-                let Some(f) = scope.get(caller) else {
-                  return None;
+                let scope1 = &ext.$x;
+                let scope2 = &ar.$x;
+
+                let f = match scope1.get(caller) {
+                  Some(v) => v,
+                  None => match scope2.get(caller) {
+                      Some(v) => v,
+                      None => { return None }
+                  },
                 };
 
                 f(data as _, v, a, c, o);