Last lua state

Author: fabi321

Cargo.toml

@@ -5,6 +5,7 @@ version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0"
 repository = "https://github.com/Aviosium/fdl"
+build = "build.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [features]
@@ -14,5 +15,5 @@ fixed_point = []
 lalrpop = "0.20.0"
 
 [dependencies]
-lalrpop-util = {version = "0.20", features = ["lexer"]}
-thiserror = "1.0.40"
+lalrpop-util = { version = "0.20", features = ["lexer"] }
+thiserror = "1.0.40"

build.rs

@@ -1,3 +1,40 @@
+use std::{
+    fs::{rename, File},
+    io::{BufRead, BufReader, BufWriter, Write},
+    path::PathBuf,
+};
+
+const TARGET: &str = "#[allow(clippy::too_many_arguments";
+
 fn main() {
+    println!("cargo::rerun-if-changed=src/parser/language.lalrpop");
     lalrpop::process_root().unwrap();
+    let base_path = PathBuf::from(std::env::var_os("OUT_DIR").expect("missing OUT_DIR variable"));
+    let path = base_path.join("parser/language.rs");
+    let out_path = base_path.join("parser/language_out.rs");
+    let input_file = File::open(&path).expect("Unable to open input file");
+    let reader = BufReader::new(input_file);
+    let output_file = File::create(&out_path).expect("unable to create output file");
+    let mut writer = BufWriter::new(output_file);
+    for line_result in reader.lines() {
+        let mut line = line_result.expect("invalid line");
+
+        // Check if the line matches the pattern
+        if line.starts_with(TARGET) {
+            // Modify the line as needed
+            line.insert_str(TARGET.len(), ", clippy::type_complexity, clippy::vec_box")
+        }
+
+        if line.starts_with("mod") {
+            writeln!(
+                writer,
+                "#[allow(clippy::vec_box, clippy::mixed_attributes_style)]"
+            )
+            .expect("Unabel to write file");
+        }
+
+        // Write the line to the output file
+        writeln!(writer, "{}", line).expect("Unable to write file");
+    }
+    rename(out_path, path).expect("unable to rename file");
 }

examples/test.fdl

@@ -0,0 +1,40 @@
+function $test(b: bounded<0..10>, c: nonzero<2..2>) -> bounded<0..5>
+    let b: [[bounded<0..10>; 5]; 2] = [[b;5];2];
+    b[0][8//2]//c
+end;
+
+function $gen_obj(val: int) -> {name: {first: int, second: int?}, other: _}
+    {
+        name = {
+            first = val,
+            second = nil,
+        },
+        other = val,
+    }
+end;
+
+function $tast(a: bounded<1..>, b: bounded<..-1>) -> bounded<..0>
+    a // b
+end;
+
+function $abc(a: float) -> float
+    let b: float = a;
+    b
+end;
+
+function $use_obj() -> int
+    let {name: {first: int}, other} = $gen_obj(1);
+    name.first
+end;
+
+function $test_len(a: _) -> bounded<0..6>
+    let b = [nil;6];
+    #b
+end;
+
+function $testt() -> int?
+end;
+
+function $main() -> int
+    $test(1, 2)
+end

src/lib.rs

@@ -1,3 +1,6 @@
 mod error;
 mod parser;
 mod type_checker;
+
+pub use parser::Parser;
+pub use type_checker::typecheck::TypeckState;

src/main.rs

@@ -0,0 +1,29 @@
+use std::time::Instant;
+
+use fdl::{Parser, TypeckState};
+
+pub fn main() {
+    let start = Instant::now();
+    let mut parser = Parser::new();
+    let path = std::env::args().nth(1).expect("Please provide a path");
+    let content = std::fs::read_to_string(path).expect("Unable to read file");
+    let result = match parser.parse(&content) {
+        Ok(ast) => ast,
+        Err(error) => {
+            print!("{}", error.print(parser.get_manager()));
+            return;
+        }
+    };
+    let mut typecheck = TypeckState::new();
+    match typecheck.check_script(&[result]) {
+        Ok(_) => {}
+        Err(error) => {
+            print!("{}", error.print(parser.get_manager()));
+            return;
+        }
+    }
+    println!(
+        "Sucessfully checked file in {:0.3}s",
+        start.elapsed().as_secs_f64()
+    );
+}

src/parser/ast.rs

@@ -41,10 +41,12 @@ pub enum UnOp {
     BitNot,
 }
 
+type SpannedType = Spanned<Box<TypeExpr>>;
+
 #[derive(Debug, Clone)]
 pub enum LetPattern {
-    Var(String),                                     // TODO
-    Record(Vec<(Spanned<String>, Box<LetPattern>)>), // TODO
+    Var((String, Option<Spanned<Readability>>, Option<SpannedType>)),
+    Record(Vec<(Spanned<String>, Option<SpannedType>, Box<LetPattern>)>),
 }
 
 #[derive(Debug, Clone)]
@@ -54,6 +56,7 @@ pub enum MatchPattern {
 }
 
 #[derive(Debug, Clone)]
+#[allow(clippy::vec_box)]
 pub enum Expr {
     BinOp(Spanned<Box<Expr>>, Spanned<Box<Expr>>, Op, Span),
     UnOp(Spanned<Box<Expr>>, UnOp, Span),
@@ -84,35 +87,45 @@ pub enum TypeExpr {
         Vec<(Spanned<String>, Box<TypeExpr>)>,
         Span,
     ), // TODO
-    Func(Spanned<(Box<TypeExpr>, Box<TypeExpr>)>), // TODO
-    Ident(Spanned<String>),                        // TODO
-    Nullable(Box<TypeExpr>, Span),                 // TODO
+    Ident(Spanned<String>),        // TODO
+    Nullable(Box<TypeExpr>, Span), // TODO
     Record(
         Option<Box<TypeExpr>>,
         Vec<(Spanned<String>, Box<TypeExpr>)>,
         Span,
     ), // TODO
-    Ref(Box<TypeExpr>, Spanned<Readability>),      // TODO
-    TypeVar(Spanned<String>),                      // TODO
+    Ref(Box<TypeExpr>, Spanned<Readability>), // TODO
+    TypeVar(Spanned<String>),      // TODO
     Alias(Box<TypeExpr>, Spanned<String>),
+    BoundedInt(
+        Vec<(Option<Spanned<String>>, Option<Spanned<String>>)>,
+        Span,
+    ),
+    NonZero(SpannedType),
+    Array(Box<TypeExpr>, String, Span),
 }
 
 #[derive(Debug, Clone)]
 pub enum TopLevel {
     Expr(Box<Expr>),
     Block(Vec<TopLevel>, Option<Spanned<Box<Expr>>>),
-    LetDef(
-        String,
-        Option<Spanned<Readability>>,
-        Option<Spanned<Box<TypeExpr>>>,
-        Box<Expr>,
-    ),
+    LetDef(LetPattern, Box<Expr>),
     Assign(Spanned<String>, Spanned<Box<Expr>>),
     FuncDef(
         Spanned<(
             String,
-            Vec<Spanned<(String, Option<Box<TypeExpr>>)>>,
+            Vec<Spanned<(String, Box<TypeExpr>)>>,
+            SpannedType,
             Box<TopLevel>,
         )>,
     ),
 }
+
+impl Default for TopLevel {
+    fn default() -> Self {
+        TopLevel::Expr(Box::new(Expr::Literal(
+            Literal::Nil,
+            ("nil".to_string(), Span(0)),
+        )))
+    }
+}

src/parser/language.lalrpop

@@ -6,11 +6,20 @@ grammar(ctx: &mut spans::SpanMaker<'input>);
 
 Ident: String = <r"[a-z_]\w*"> => String::from(<>);
 
+
 IntLiteral: String = {
-    r"(?:0|[1-9][0-9]*)" => String::from(<>),
+    r"0|[1-9][0-9]*" => String::from(<>),
+};
+SignedIntLiteral: String = {
+    <IntLiteral>,
+    r"-(?:0|[1-9][0-9]*)" => String::from(<>),
 };
+
 FloatLiteral: String =
-    r"(?:0|[1-9][0-9]*)\.[0-9]*(?:[eE]-?[0-9]+)?" => String::from(<>);
+    <mut i:IntLiteral><f:r"\.[0-9]*(?:[eE]-?[0-9]+)?"> => {
+        i.push_str(f);
+        i
+};
 
 Readability: ast::Readability = {
     "<readonly>" => ast::Readability::ReadOnly,
@@ -172,8 +181,26 @@ Expr = {
     If,
 };
 
+TypeKeyPair: (spans::Spanned<String>, Box<ast::TypeExpr>) = {
+    <Spanned<Ident>> ":" <TypeExpr>,
+};
+
+Range: (Option<spans::Spanned<String>>, Option<spans::Spanned<String>>) = {
+    <Spanned<SignedIntLiteral>?> ".." <Spanned<SignedIntLiteral>?>
+};
+
+BoundedInt: Vec<(Option<spans::Spanned<String>>, Option<spans::Spanned<String>>)> = {
+    SepList<Range, ",">
+};
+
 TypeExpr: Box<ast::TypeExpr> = {
+    "(" <TypeExpr> ")",
+    <t:Spanned<("[" <TypeExpr> ";" <IntLiteral> "]")>> => Box::new(ast::TypeExpr::Array(t.0.0, t.0.1, t.1)),
+    <t:Spanned<(<TypeExpr> "?")>> => Box::new(ast::TypeExpr::Nullable(t.0, t.1)),
+    <s:Spanned<("bounded" "<" <BoundedInt> ">")>> => Box::new(ast::TypeExpr::BoundedInt(s.0, s.1)),
+    <s:Spanned<("nonzero" "<" <Spanned<BoundedInt>> ">")>> => Box::new(ast::TypeExpr::NonZero((Box::new(ast::TypeExpr::BoundedInt(s.0.0, s.0.1)), s.1))),
     Spanned<Ident> => Box::new(ast::TypeExpr::Ident(<>)),
+    <t:Spanned<("{" <SepList<TypeKeyPair, ",">> "}")>> => Box::new(ast::TypeExpr::Record(None, t.0, t.1)),
 };
 
 CoreIf: Box<ast::Expr> = {
@@ -185,8 +212,22 @@ If: Box<ast::Expr> = {
     "if" <CoreIf>
 };
 
+ReadableType: (Option<spans::Spanned<ast::Readability>>, Option<spans::Spanned<Box<ast::TypeExpr>>>) = {
+    <Spanned<Readability>?> <(":" <Spanned<TypeExpr>>)?>
+}
+
+KeyPairPattern: (spans::Spanned<String>, Option<spans::Spanned<Box<ast::TypeExpr>>>, Box<ast::LetPattern>) = {
+    <name: Spanned<Ident>> "=" <pat: LetPattern> => (name, None, Box::new(pat)),
+    <name: Spanned<Ident>> <type_: ReadableType> => (name.clone(), None, Box::new(ast::LetPattern::Var((name.0, type_.0, type_.1)))),
+}
+
+LetPattern: ast::LetPattern = {
+    <name: Ident> <type_: ReadableType>  => ast::LetPattern::Var((name, type_.0, type_.1)),
+    "{" <SepList<KeyPairPattern, ",">> "}" => ast::LetPattern::Record(<>),
+}
+
 LetStatement: ast::TopLevel = {
-    "let" <Ident> <Spanned<Readability>?> <(":" <Spanned<TypeExpr>>)?> "=" <Expr> => ast::TopLevel::LetDef(<>),
+    "let" <LetPattern> "=" <Expr> => ast::TopLevel::LetDef(<>),
 };
 
 Assignment: ast::TopLevel = {
@@ -205,9 +246,9 @@ ColonType = {
 }
 
 FuncDef: ast::TopLevel = {
-    Spanned<("function" "$" <Ident> "(" <SepList<Spanned<(Ident ColonType?)>, ",">> ")" <Block> "end")> => {
-        let ((name, arguments, block), span) = <>;
-        ast::TopLevel::FuncDef(((name, arguments, Box::new(block)), span))
+    Spanned<("function" "$" <Ident> "(" <SepList<Spanned<(Ident ColonType)>, ",">> ")" "->" <Spanned<TypeExpr>> <Block> "end")> => {
+        let ((name, arguments, retype, block), span) = <>;
+        ast::TopLevel::FuncDef(((name, arguments, retype, Box::new(block)), span))
     }
 };
 

src/parser/mod.rs

@@ -36,7 +36,7 @@ fn convert_parse_error<T: Display>(
         ParseError::ExtraToken { token } => {
             SpannedError::new1("SyntaxError: Unexpected extra token", sm.span(token.0, token.2))
         }
-        ParseError::User { error: msg } => unreachable!(),
+        ParseError::User { error: _msg } => unreachable!(),
     }
 }
 
@@ -53,23 +53,28 @@ impl Parser {
         }
     }
 
-    pub fn parse(
-        &mut self,
-        source_path: &str,
-        content: &str,
-    ) -> Result<ast::TopLevel, SpannedError> {
-        let mut span_maker = self.spans.add_source(source_path.to_string());
+    pub fn parse(&mut self, content: &str) -> Result<ast::TopLevel, SpannedError> {
+        let mut span_maker = self.spans.add_source(content.to_string());
 
         self.parser
             .parse(&mut span_maker, content)
             .map_err(|e| convert_parse_error(span_maker, e))
     }
+
+    pub fn get_manager(&self) -> &SpanManager {
+        &self.spans
+    }
+}
+
+impl Default for Parser {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parser::spans::SpanManager;
 
     #[test]
     fn test_basic_script() {
@@ -93,6 +98,6 @@ mod tests {
                 c
             end;";
         let mut parser = Parser::new();
-        let ast = parser.parse("temp", script).unwrap();
+        let _ast = parser.parse(script).unwrap();
     }
 }