x

Author: oovm

Cargo.toml

@@ -1,10 +1,22 @@
 [workspace]
 resolver = "3"
 members = [
-    "compilers/*",
+    "compilers/python",
+    "compilers/python-ir",
+    "compilers/python-lsp",
+    "compilers/python-macros",
+    "compilers/python-tools",
+    "compilers/python-types",
+    "compilers/python-wasi",
 ]
 default-members = [
-    "compilers/*",
+    "compilers/python",
+    "compilers/python-ir",
+    "compilers/python-lsp",
+    "compilers/python-macros",
+    "compilers/python-tools",
+    "compilers/python-types",
+    "compilers/python-wasi",
 ]
 
 [workspace.package]

compilers/python/src/codegen.rs

@@ -3,8 +3,8 @@
 //! This module is responsible for generating bytecode from AST nodes.
 
 use oak_python::ast::{
-    BinaryOperator, BoolOperator, CompareOperator as ComparisonOperator, Comprehension, ExceptHandler, Expression, Keyword,
-    Literal, Parameter, Pattern, Statement, UnaryOperator,
+    AugmentedOperator, BinaryOperator, BoolOperator, CompareOperator as ComparisonOperator, Comprehension, ExceptHandler, Expression, ImportName, Keyword,
+    Literal, Parameter, Statement, Type, UnaryOperator, WithItem,
 };
 use python_types::PythonResult;
 use smallvec::SmallVec;
@@ -162,7 +162,7 @@ impl CodeGenerator {
                 self.generate_if(Box::new(test), body, orelse)?;
             }
             Statement::For { target, iter, body, orelse } => {
-                self.generate_for(Box::new(target), Box::new(iter), body, orelse)?;
+                self.generate_for(target, iter, body, orelse)?;
             }
             Statement::While { test, body, orelse } => {
                 self.generate_while(Box::new(test), body, orelse)?;
@@ -171,17 +171,10 @@ impl CodeGenerator {
                 self.generate_try(body, handlers, orelse, finalbody)?;
             }
             Statement::With { items, body } => {
-                let items = items.into_iter().map(|item| (item.context_expr, item.optional_vars.map(Box::new))).collect();
                 self.generate_with(items, body)?;
             }
             Statement::Return(value) => {
-                self.generate_return(value.map(Box::new))?;
-            }
-            Statement::Yield(value) => {
-                self.generate_yield(value)?;
-            }
-            Statement::YieldFrom(value) => {
-                self.generate_yield_from(value)?;
+                self.generate_return(value)?;
             }
             Statement::Break => {
                 self.instructions.push(Instruction::Break);
@@ -199,11 +192,11 @@ impl CodeGenerator {
                 self.generate_assert(Box::new(test), msg.map(Box::new))?;
             }
             Statement::Import { names } => {
-                let names = names.into_iter().map(|name| (name.name, name.asname)).collect();
+                let names = names.into_iter().map(|name| (name.name, name.alias)).collect();
                 self.generate_import(names)?;
             }
-            Statement::ImportFrom { module, names, level: _ } => {
-                let names = names.into_iter().map(|name| (name.name, name.asname)).collect();
+            Statement::ImportFrom { module, names } => {
+                let names = names.into_iter().map(|name| (name.name, name.alias)).collect();
                 self.generate_import_from(module, names, 0)?;
             }
             Statement::Global { names } => {
@@ -213,13 +206,12 @@ impl CodeGenerator {
                 self.generate_nonlocal(names)?;
             }
             Statement::Assignment { target, value } => {
-                self.generate_assign(vec![Pattern::Value(target)], Box::new(value))?;
+                self.generate_assign(target, value)?;
             }
             Statement::AugmentedAssignment { target, operator, value } => {
-                self.generate_aug_assign(Box::new(Pattern::Value(target)), operator, Box::new(value))?;
+                self.generate_aug_assign(target, operator, value)?;
             }
             Statement::Delete { targets } => {
-                let targets = targets.into_iter().map(Pattern::Value).collect();
                 self.generate_del(targets)?;
             }
             Statement::Expression(value) => {
@@ -409,11 +401,12 @@ impl CodeGenerator {
         &mut self,
         name: String,
         parameters: Vec<Parameter>,
-        return_type: Option<Box<Expression>>,
+        return_type: Option<Type>,
         body: Vec<Statement>,
         decorators: Vec<Expression>,
     ) -> PythonResult<()> {
         // TODO: Implement function definition
+        let _ = (name, parameters, return_type, body, decorators);
         Ok(())
     }
 
@@ -464,12 +457,13 @@ impl CodeGenerator {
     /// Generate bytecode for a for statement
     fn generate_for(
         &mut self,
-        target: Box<Pattern>,
-        iter: Box<Expression>,
+        target: Expression,
+        iter: Expression,
         body: Vec<Statement>,
         orelse: Vec<Statement>,
     ) -> PythonResult<()> {
         // TODO: Implement for loop
+        let _ = (target, iter, body, orelse);
         Ok(())
     }
 
@@ -492,15 +486,16 @@ impl CodeGenerator {
     }
 
     /// Generate bytecode for a with statement
-    fn generate_with(&mut self, items: Vec<(Expression, Option<Pattern>)>, body: Vec<Statement>) -> PythonResult<()> {
+    fn generate_with(&mut self, items: Vec<WithItem>, body: Vec<Statement>) -> PythonResult<()> {
         // TODO: Implement with statement
+        let _ = (items, body);
         Ok(())
     }
 
     /// Generate bytecode for a return statement
-    fn generate_return(&mut self, value: Option<Box<Expression>>) -> PythonResult<()> {
+    fn generate_return(&mut self, value: Option<Expression>) -> PythonResult<()> {
         if let Some(value) = value {
-            self.generate_expression(*value)?;
+            self.generate_expression(value)?;
         }
         else {
             self.instructions.push(Instruction::PushNull);
@@ -509,35 +504,18 @@ impl CodeGenerator {
         Ok(())
     }
 
-    /// Generate bytecode for a yield statement
-    fn generate_yield(&mut self, value: Option<Box<Expression>>) -> PythonResult<()> {
-        if let Some(value) = value {
-            self.generate_expression(*value)?;
-        }
-        else {
-            self.instructions.push(Instruction::PushNull);
-        }
-        self.instructions.push(Instruction::Yield);
-        Ok(())
-    }
-
-    /// Generate bytecode for a yield from statement
-    fn generate_yield_from(&mut self, value: Box<Expression>) -> PythonResult<()> {
-        self.generate_expression(*value)?;
-        self.instructions.push(Instruction::YieldFrom);
-        Ok(())
-    }
-
     /// Generate bytecode for a raise statement
-    fn generate_raise(&mut self, exc: Option<Box<Expression>>, cause: Option<Box<Expression>>) -> PythonResult<()> {
+    fn generate_raise(&mut self, exc: Option<Expression>, cause: Option<Expression>) -> PythonResult<()> {
         // TODO: Implement raise statement
+        let _ = (exc, cause);
         self.instructions.push(Instruction::Raise);
         Ok(())
     }
 
     /// Generate bytecode for an assert statement
-    fn generate_assert(&mut self, test: Box<Expression>, msg: Option<Box<Expression>>) -> PythonResult<()> {
+    fn generate_assert(&mut self, test: Expression, msg: Option<Expression>) -> PythonResult<()> {
         // TODO: Implement assert statement
+        let _ = (test, msg);
         Ok(())
     }
 
@@ -571,20 +549,23 @@ impl CodeGenerator {
     }
 
     /// Generate bytecode for an assign statement
-    fn generate_assign(&mut self, targets: Vec<Pattern>, value: Box<Expression>) -> PythonResult<()> {
+    fn generate_assign(&mut self, target: Expression, value: Expression) -> PythonResult<()> {
         // TODO: Implement assign statement
+        let _ = (target, value);
         Ok(())
     }
 
     /// Generate bytecode for an augmented assign statement
-    fn generate_aug_assign(&mut self, target: Box<Pattern>, op: BinaryOperator, value: Box<Expression>) -> PythonResult<()> {
+    fn generate_aug_assign(&mut self, target: Expression, op: AugmentedOperator, value: Expression) -> PythonResult<()> {
         // TODO: Implement augmented assign statement
+        let _ = (target, op, value);
         Ok(())
     }
 
     /// Generate bytecode for a del statement
-    fn generate_del(&mut self, targets: Vec<Pattern>) -> PythonResult<()> {
+    fn generate_del(&mut self, targets: Vec<Expression>) -> PythonResult<()> {
         // TODO: Implement del statement
+        let _ = targets;
         Ok(())
     }
 

frontends/homepage/package.json

@@ -1,8 +1,8 @@
 {
+    "private": true,
     "name": "@nyar/python-homepage",
     "version": "0.1.0",
     "description": "RBQ Engine Homepage and Documentation",
-    "private": true,
     "type": "module",
     "scripts": {
         "dev": "vite",

package.json

@@ -18,6 +18,8 @@
         "dev": "pnpm -F @vutex/documentation dev",
         "build": "pnpm -F @vutex/documentation build",
         "preview": "pnpm -F @vutex/documentation preview",
+        "dev:home": "pnpm -F @nyar/python-homepage dev",
+        "build:home": "pnpm -F @nyar/python-homepage build",
         "build:release": "tsx scripts/build-release.ts",
         "u": "cargo upgrade --workspace",
         "p": "cargo workspace publish --resume",