Merge pull request #7 from yazaldefilimone/chore/ci

refactor: remove functions scope and add builtin functions, #4

.github/workflows/codspeed.yml

@@ -0,0 +1,30 @@
+name: Codspeed Benchmark
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup rust toolchain, cache and cargo-codspeed binary
+        uses: moonrepo/setup-rust@v0
+        with:
+          channel: stable
+          cache-target: release
+          bins: cargo-codspeed
+
+      - name: Build the benchmark target(s)
+        run: cargo codspeed build
+
+      - name: Run the benchmarks
+        uses: CodSpeedHQ/action@main
+        with:
+          run: cargo codspeed run
+          token: ${{ secrets.CODSPEED_TOKEN }}
+
+  # for file in ./tests/golden_tests/*.lua; do
+  #             codspeed bench "./target/release/stella check $file"
+  # done

.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: CI Tests
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the code
+        uses: actions/checkout@v2
+
+      - name: Set up Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Run tests
+        run: cargo test --all

Cargo.toml

@@ -12,6 +12,8 @@ code_highlighter = "0.1.1"
 serde = { version = "1.0.204", features = ["derive"] }
 
 [dev-dependencies]
+codspeed = "2.6.0"
+criterion = "0.5.1"
 glob = "0.3.1"
 insta = { version = "1.39.0", features = ["ron"] }
 
@@ -21,3 +23,15 @@ debug = false     # Não incluir informações de depuração
 lto = "fat"       # Link Time Optimization, "fat" aplica otimizações mais agressivas
 panic = "abort"   # Abortar no caso de pânico, em vez de desempilhar
 codegen-units = 1 # Reduzir o número de unidades de geração de código para melhorar a otimização
+
+[[bench]]
+name = "stella_lexer_benchmark"
+path = "benches/lexer_benchmark.rs"
+
+[[bench]]
+name = "stella_parser_benchmark"
+path = "benches/parser_benchmark.rs"
+
+[[bench]]
+name = "stella_checker_benchmark"
+path = "benches/checker_benchmark.rs"

benches/checker_benchmark.rs

@@ -0,0 +1,38 @@
+#![allow(dead_code, unused_imports)]
+// use codspeed::{codspeed::black_box, codspeed_bench, codspeed_main};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use glob::glob;
+
+pub fn lexer_benchmark(c: &mut criterion::Criterion) {
+  let paths_names = vec![
+    "tests/golden_tests/assign_expression.lua",
+    "tests/golden_tests/boolean_logic.lua",
+    "tests/golden_tests/conditional_statement.lua",
+    "tests/golden_tests/if_statement.lua",
+    "tests/golden_tests/nested_functions.lua",
+    "tests/golden_tests/simple_declaration.lua",
+  ];
+  let mut patterns = Vec::new();
+  for path_name in paths_names {
+    let path = std::path::Path::new(path_name);
+    let file_name = path.file_name().unwrap().to_string_lossy().to_string();
+    let content = std::fs::read_to_string(path).expect("Failed to read file");
+    patterns.push((file_name.to_owned(), content));
+  }
+  // checker
+  for (file_name, source_code) in patterns.iter() {
+    c.bench_function(format!("checker_{}", file_name).as_str(), |b| {
+      b.iter(|| {
+        let checker = &mut stella::checker::Checker::new();
+        let check = checker.check(&stella::parser::parser::Parser::new(source_code).parse_program());
+        match check {
+          Ok(t) => black_box(t),
+          _ => black_box(stella::types::Type::Unknown),
+        }
+      });
+    });
+  }
+}
+
+criterion_group!(benches, lexer_benchmark);
+criterion_main!(benches);

benches/lexer_benchmark.rs

@@ -0,0 +1,26 @@
+#![allow(dead_code, unused_imports)]
+// use codspeed::{codspeed::black_box, codspeed_bench, codspeed_main};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use glob::glob;
+
+pub fn lexer_benchmark(c: &mut criterion::Criterion) {
+  let mut patterns = Vec::new();
+  let glob_pattern = glob("tests/golden_tests/*.lua").expect("Failed to read glob pattern");
+  for entry in glob_pattern {
+    let path = entry.expect("Failed to read file");
+    let file_name = path.file_name().unwrap().to_string_lossy().to_string();
+    let content = std::fs::read_to_string(path).expect("Failed to read file");
+    patterns.push((file_name.to_owned(), content));
+  }
+
+  for (file_name, source_code) in patterns.iter() {
+    c.bench_function(format!("lexer_{}", file_name).as_str(), |b| {
+      b.iter(|| {
+        black_box(stella::lexer::Lexer::new(source_code.to_string()));
+      });
+    });
+  }
+}
+
+criterion_group!(benches, lexer_benchmark);
+criterion_main!(benches);

benches/parser_benchmark.rs

@@ -0,0 +1,26 @@
+#![allow(dead_code, unused_imports)]
+// use codspeed::{codspeed::black_box, codspeed_bench, codspeed_main};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use glob::glob;
+
+pub fn lexer_benchmark(c: &mut criterion::Criterion) {
+  let mut patterns = Vec::new();
+  let glob_pattern = glob("tests/golden_tests/*.lua").expect("Failed to read glob pattern");
+  for entry in glob_pattern {
+    let path = entry.expect("Failed to read file");
+    let file_name = path.file_name().unwrap().to_string_lossy().to_string();
+    let content = std::fs::read_to_string(path).expect("Failed to read file");
+    patterns.push((file_name.to_owned(), content));
+  }
+
+  for (file_name, source_code) in patterns.iter() {
+    c.bench_function(format!("parser_{}", file_name).as_str(), |b| {
+      b.iter(|| {
+        black_box(stella::parser::parser::Parser::new(source_code).parse_program());
+      });
+    });
+  }
+}
+
+criterion_group!(benches, lexer_benchmark);
+criterion_main!(benches);