Merge branch 'aspizu:main' into main

Author: some100

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "goboscript"
-version = "1.2.0"
+version = "2.0.0"
 edition = "2021"
 
 [dependencies]
@@ -13,13 +13,15 @@ clap_complete_command = "0.6.1"
 clap_derive = "4.5.18"
 colored = "2.1.0"
 csscolorparser = "0.7.0"
+directories = "6.0.0"
 fxhash = "0.2.1"
 glob = "0.3.1"
 lalrpop-util = "0.22.0"
 log = "0.4.22"
 logos = "0.14.2"
 md-5 = "0.10.6"
 pretty_env_logger = "0.5.0"
+semver = "1.0.25"
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0.128"
 toml = "0.8.19"

Cargo.toml

@@ -1,4 +1,5 @@
 mod arg;
+mod const_expr;
 mod costume;
 mod enum_;
 mod enum_variant;
@@ -21,6 +22,7 @@ mod value;
 mod var;
 
 pub use arg::*;
+pub use const_expr::*;
 pub use costume::*;
 pub use enum_::*;
 pub use enum_variant::*;

src/ast.rs

@@ -0,0 +1,65 @@
+use logos::Span;
+
+use super::Value;
+use crate::blocks::{
+    BinOp,
+    UnOp,
+};
+
+#[derive(Debug, Clone)]
+pub enum ConstExpr {
+    Value {
+        value: Value,
+        span: Span,
+    },
+    UnOp {
+        op: UnOp,
+        span: Span,
+        opr: Box<ConstExpr>,
+    },
+    BinOp {
+        op: BinOp,
+        span: Span,
+        lhs: Box<ConstExpr>,
+        rhs: Box<ConstExpr>,
+    },
+}
+
+impl ConstExpr {
+    pub fn span(&self) -> Span {
+        match self {
+            Self::Value { span, .. } => span.clone(),
+            Self::UnOp { span, .. } => span.clone(),
+            Self::BinOp { span, .. } => span.clone(),
+        }
+    }
+
+    pub fn evaluate(&self) -> Value {
+        match self {
+            Self::Value { value, .. } => value.clone(),
+            Self::UnOp { op, opr, .. } => opr.evaluate().unop(*op).unwrap(),
+            Self::BinOp { op, lhs, rhs, .. } => lhs.evaluate().binop(*op, &rhs.evaluate()).unwrap(),
+        }
+    }
+}
+
+impl UnOp {
+    pub fn to_const_expr(self, span: Span, expr: ConstExpr) -> ConstExpr {
+        ConstExpr::UnOp {
+            op: self,
+            span,
+            opr: Box::new(expr),
+        }
+    }
+}
+
+impl BinOp {
+    pub fn to_const_expr(self, span: Span, lhs: ConstExpr, rhs: ConstExpr) -> ConstExpr {
+        ConstExpr::BinOp {
+            op: self,
+            span,
+            lhs: Box::new(lhs),
+            rhs: Box::new(rhs),
+        }
+    }
+}

src/ast/const_expr.rs

@@ -2,7 +2,7 @@ use logos::Span;
 
 use super::{
     type_::Type,
-    Value,
+    ConstExpr,
 };
 use crate::misc::SmolStr;
 
@@ -17,7 +17,7 @@ pub struct List {
 
 #[derive(Debug)]
 pub enum ListDefault {
-    Literal(Vec<(Value, Span)>),
+    ConstExprs(Vec<ConstExpr>),
     Cmd(Cmd),
 }
 
@@ -55,12 +55,12 @@ impl List {
         }
     }
 
-    pub fn new_array(name: SmolStr, span: Span, type_: Type, default: Vec<(Value, Span)>) -> Self {
+    pub fn new_array(name: SmolStr, span: Span, type_: Type, default: Vec<ConstExpr>) -> Self {
         Self {
             name,
             span,
             type_,
-            default: Some(ListDefault::Literal(default)),
+            default: Some(ListDefault::ConstExprs(default)),
             is_used: false,
         }
     }
@@ -72,9 +72,9 @@ impl List {
         }
     }
 
-    pub fn array(&self) -> Option<&[(Value, Span)]> {
+    pub fn array(&self) -> Option<&[ConstExpr]> {
         match &self.default {
-            Some(ListDefault::Literal(array)) => Some(array),
+            Some(ListDefault::ConstExprs(array)) => Some(array),
             _ => None,
         }
     }

src/ast/list.rs

@@ -7,7 +7,10 @@ use std::fmt::{
 
 use logos::Span;
 
-use super::Expr;
+use super::{
+    ConstExpr,
+    Expr,
+};
 use crate::misc::SmolStr;
 
 #[derive(Debug, Clone)]
@@ -80,4 +83,9 @@ impl Value {
     pub fn to_expr(self, span: Span) -> Expr {
         Expr::Value { value: self, span }
     }
+
+    #[allow(clippy::wrong_self_convention)]
+    pub fn to_const_expr(self, span: Span) -> ConstExpr {
+        ConstExpr::Value { value: self, span }
+    }
 }

src/ast/value.rs

@@ -21,7 +21,7 @@ impl Value {
             UnOp::Log => None,
             UnOp::AntiLn => None,
             UnOp::AntiLog => None,
-            UnOp::Minus => None,
+            UnOp::Minus => self.minus(),
         }
     }
 
@@ -46,4 +46,12 @@ impl Value {
             _ => None,
         }
     }
+
+    fn minus(&self) -> Option<Value> {
+        match self {
+            Self::Int(int) => Some((-*int).into()),
+            Self::Float(float) => Some((-*float).into()),
+            _ => None,
+        }
+    }
 }

src/ast/value/unop.rs

@@ -1123,9 +1123,7 @@ impl Repr {
     }
 
     pub fn overloads(name: &str) -> &'static [Self] {
-        match name {
-            _ => &[],
-        }
+        &[]
     }
 
     pub fn from_shape(name: &str, args: usize) -> Option<Self> {

src/blocks.rs

@@ -41,8 +41,8 @@ impl Display for Mutation<'_> {
         write!(f, r#","mutation":{{"tagName":"mutation","children":[]"#)?;
         write!(f, r#","warp":"{}""#, self.warp)?;
         write!(f, r#","proccode":"{}"#, self.name)?;
-        for _ in 0..self.args.len() {
-            write!(f, " %s")?;
+        for (arg_name, _) in self.args {
+            write!(f, " {arg_name}: %s")?;
         }
         write!(f, "\"")?;
         write!(f, r#","argumentids":"["#)?;

src/codegen/mutation.rs

@@ -708,7 +708,7 @@ where T: Write + Seek
                 list.array().map(|array| {
                     array
                         .iter()
-                        .map(|(value, _)| value.to_string())
+                        .map(|const_expr| const_expr.evaluate().to_string())
                         .collect::<Vec<_>>()
                 })
             });

src/codegen/sb3.rs

@@ -3,8 +3,10 @@ use serde::{
     Serialize,
 };
 
-#[derive(Debug, Serialize, Deserialize, Default, PartialEq, Clone, Copy)]
+#[derive(Debug, Serialize, Deserialize, Default, PartialEq, Clone)]
 pub struct Config {
+    #[serde(default)]
+    pub std: Option<String>,
     #[serde(default)]
     pub frame_rate: Option<u64>,
     #[serde(default)]

src/config.rs

@@ -19,7 +19,11 @@ use super::{
 };
 use crate::{
     ast::Project,
-    translation_unit::TranslationUnit,
+    standard_library::StandardLibrary,
+    translation_unit::{
+        Owner,
+        TranslationUnit,
+    },
 };
 
 pub struct SpriteDiagnostics {
@@ -29,12 +33,12 @@ pub struct SpriteDiagnostics {
 }
 
 impl SpriteDiagnostics {
-    pub fn new(path: PathBuf) -> Self {
+    pub fn new(path: PathBuf, stdlib: &StandardLibrary) -> Self {
         let sprite_name = path.file_stem().unwrap().to_str().unwrap().to_string();
         let mut translation_unit = TranslationUnit::new(path);
         let mut diagnostics = vec![];
-        if let Err(diagnostic) = translation_unit.pre_process() {
-            diagnostics.push(diagnostic);
+        if let Err(diagnostic) = translation_unit.pre_process(stdlib) {
+            diagnostics.extend(diagnostic);
         }
         Self {
             sprite_name,
@@ -63,13 +67,12 @@ impl SpriteDiagnostics {
             let (start, include) = self
                 .translation_unit
                 .translate_position(diagnostic.span.start);
-            // Do not display diagnostics for standard library headers.
-            let Some(include_path) = &include.path else {
+            if !matches!(include.owner, Owner::Local) {
                 continue;
-            };
+            }
             // TODO: memoize this using a memoization crate.
-            let text = fs::read_to_string(include_path).unwrap();
-            let include_path = include_path.to_str().unwrap();
+            let text = fs::read_to_string(&include.path).unwrap();
+            let include_path = include.path.to_str().unwrap();
             if diagnostic.span.start == 0 && diagnostic.span.end == 0 {
                 let mut message = level
                     .title(&title)