feat: impl methods on transpiler

fcoury · Jul 10, 2024 · 5d7fcec · 5d7fcec
1 parent 6167929
commit 5d7fcec
Show file tree

Hide file tree

Showing 9 changed files with 172 additions and 128 deletions.
diff --git a/examples/hello.rusk b/examples/hello.rusk
diff --git a/src/error.rs b/src/error.rs
@@ -9,6 +9,7 @@ pub enum Error {
     Semantic(String, Span),
     Parse(String, Span),
     Runtime(String, Span),
+    Transpiler(String, Span),
 }
 
 #[allow(dead_code)]
@@ -25,11 +26,16 @@ impl Error {
         Error::Runtime(message.into(), span)
     }
 
+    pub fn new_transpile(message: impl Into<String>, span: Span) -> Self {
+        Error::Transpiler(message.into(), span)
+    }
+
     pub fn pretty_print(&self, code: impl Into<String>) -> String {
         match self {
             Error::Semantic(message, span) => pretty_print(code, message, span),
             Error::Parse(message, span) => pretty_print(code, message, span),
             Error::Runtime(message, span) => pretty_print(code, message, span),
+            Error::Transpiler(message, span) => pretty_print(code, message, span),
         }
     }
 
@@ -38,6 +44,7 @@ impl Error {
             Error::Semantic(_, span) => span,
             Error::Parse(_, span) => span,
             Error::Runtime(_, span) => span,
+            Error::Transpiler(_, span) => span,
         }
     }
 
@@ -46,6 +53,7 @@ impl Error {
             Error::Semantic(message, _) => message,
             Error::Parse(message, _) => message,
             Error::Runtime(message, _) => message,
+            Error::Transpiler(message, _) => message,
         }
     }
 }
@@ -60,6 +68,9 @@ impl fmt::Display for Error {
             }
             Error::Parse(message, span) => write!(f, "Parse error: {} at {:?}", message, span),
             Error::Runtime(message, span) => write!(f, "Runtime error: {} at {:?}", message, span),
+            Error::Transpiler(message, span) => {
+                write!(f, "Transpiler error: {} at {:?}", message, span)
+            }
         }
     }
 }

diff --git a/src/interpreter.rs b/src/interpreter.rs
@@ -544,46 +544,43 @@ impl Interpreter {
             //         value,
             //     ))
             // }
-            Expr::Assign(left, right, span) => {
-                match left.as_ref() {
-                    Expr::Identifier(name, _) => {
-                        // TODO: mutability
-                        let value = self.evaluate_expr(right)?;
-                        self.environment.insert(name.clone(), value);
+            Expr::Assign(left, right, span) => match left.as_ref() {
+                Expr::Identifier(name, _) => {
+                    let value = self.evaluate_expr(right)?;
+                    self.environment.insert(name.clone(), value);
+                    Ok(Value::Unit)
+                }
+                Expr::MemberAccess(access_expr, field_name, _) => match access_expr.as_ref() {
+                    Expr::Identifier(name, span) => {
+                        let new_value = self.evaluate_expr(right)?;
+
+                        let Some(value) = self.environment.get_mut(name) else {
+                            return Err(Error::new_runtime(
+                                format!("Undefined struct instance: {}", name),
+                                *span,
+                            ));
+                        };
+
+                        let Some(instance) = value.as_mut_instance() else {
+                            return Err(Error::new_runtime(
+                                format!("{} is not a struct instance", name),
+                                *span,
+                            ));
+                        };
+
+                        instance.get_mut(field_name).map(|field| *field = new_value);
                         Ok(Value::Unit)
                     }
-                    Expr::MemberAccess(access_expr, field_name, _) => match access_expr.as_ref() {
-                        Expr::Identifier(name, span) => {
-                            let new_value = self.evaluate_expr(right)?;
-
-                            let Some(value) = self.environment.get_mut(name) else {
-                                return Err(Error::new_runtime(
-                                    format!("Undefined struct instance: {}", name),
-                                    *span,
-                                ));
-                            };
-
-                            let Some(instance) = value.as_mut_instance() else {
-                                return Err(Error::new_runtime(
-                                    format!("{} is not a struct instance", name),
-                                    *span,
-                                ));
-                            };
-
-                            instance.get_mut(field_name).map(|field| *field = new_value);
-                            Ok(Value::Unit)
-                        }
-                        _ => Err(Error::new_runtime(
-                            "Invalid assignment target".to_string(),
-                            *span,
-                        )),
-                    },
                     _ => Err(Error::new_runtime(
                         "Invalid assignment target".to_string(),
                         *span,
                     )),
-                }
-            }
+                },
+                _ => Err(Error::new_runtime(
+                    "Invalid assignment target".to_string(),
+                    *span,
+                )),
+            },
             Expr::CompoundAssign(left, op, right, span) => match left.as_ref() {
                 Expr::Identifier(name, _) => {
                     let left_value = self.environment.get(name).cloned().ok_or_else(|| {
@@ -949,7 +946,6 @@ mod tests {
             }
         "#;
 
-        // FIXME: identify why this is returning void
         assert_eq!(run_code(code, None).unwrap(), Value::Int(0));
     }
 

diff --git a/src/lib.rs b/src/lib.rs
@@ -42,5 +42,5 @@ pub fn transpile_to_js(code: impl Into<String>) -> Result<String> {
     analyzer.analyze(&ast)?;
 
     let js_generator = JsTranspiler::new();
-    Ok(js_generator.generate(&ast))
+    Ok(js_generator.generate(&ast)?)
 }
diff --git a/src/parser.rs b/src/parser.rs
@@ -563,7 +563,7 @@ impl Parser {
                 let variant_type = self.consume_type().unwrap();
                 if self.current_token().kind != TokenKind::RParen {
                     return Err(Error::new_parse(
-                        "Expected ')' after variant type".to_string(),
+                        "Expected ')' after associated value".to_string(),
                         self.current_token().span,
                     ));
                 }