mist-go/mist
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity

Merge pull request #63 from mist-go/syntax-patches

Browse Source 
Syntax patches & bootstrapping
This commit is contained in:
selimaj-dev
2026-06-04 17:18:26 +02:00
committed by GitHub
parent 5771d15d74 fc4dd0aa3c
commit 20d9641dda
11 changed files with 124 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/codegen/src/lib.rs
+18 -5
View File
@@ -236,6 +236,8 @@ impl GetRust for TypeExprKind {
impl GenRust for Pattern { impl GenRust for Pattern {
fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) { fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
match self { match self {
Self::Etc => cg.add(".."),
Self::Literal(lit) => lit.gen_rust(ctx, cg),
Self::Path(mutable, path) => { Self::Path(mutable, path) => {
if *mutable { if *mutable {
cg.add("mut "); cg.add("mut ");
@@ -243,15 +245,26 @@ impl GenRust for Pattern {
cg.add(&path.get_rust()) cg.add(&path.get_rust())
} }
Self::Literal(lit) => lit.gen_rust(ctx, cg),
Self::Struct(path, inner) => { Self::Struct(path, inner) => {
cg.add(&path.get_rust()); cg.add(&path.get_rust());
cg.add(" {"); cg.add(" {");
for pat in inner {
pat.gen_rust(ctx, cg); for (idx, i) in inner.iter().enumerate() {
cg.add(","); if idx > 0 {
cg.add(", ");
} }
if let Some((name, pat)) = i {
cg.add(&name.get_rust());
if let Some(pat) = pat {
cg.add(": ");
pat.gen_rust(ctx, cg);
}
} else {
cg.add("..");
}
}
cg.add("}"); cg.add("}");
} }
crates/codegen/src/top_level.rs
+27 -25
View File
@@ -175,7 +175,27 @@ impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
self.1.item.generics.get_rust() self.1.item.generics.get_rust()
)); ));
self.1.item.params.gen_rust(ctx, cg); let params = self
.1
.item
.params
.0
.clone()
.into_iter()
.enumerate()
.map(|(idx, mut v)| {
v.name = construct_pattern(&v.name, idx);
(idx, v)
})
.collect::<Vec<_>>();
for (i, param) in &params {
if *i > 0 {
cg.add(", ");
}
param.gen_rust(ctx, cg);
}
cg.addln(") -> Self {"); cg.addln(") -> Self {");
cg.indent += 1; cg.indent += 1;
@@ -196,21 +216,13 @@ impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
cg.add_indented(&format!("this.constructor(")); cg.add_indented(&format!("this.constructor("));
for (i, param) in self for (i, param) in params {
.1
.item
.params
.0
.iter()
.map(|v| expr_pattern(&v.name))
.enumerate()
{
if i > 0 { if i > 0 {
cg.add(", "); cg.add(", ");
} }
ctx.expr_ensure_semicolon = false; ctx.expr_ensure_semicolon = false;
param.gen_rust(ctx, cg); param.name.gen_rust(ctx, cg);
} }
cg.addln(");"); cg.addln(");");
@@ -246,21 +258,11 @@ impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
} }
} }
pub fn expr_pattern(pat: &Pattern) -> Expression { fn construct_pattern(pat: &Pattern, idx: usize) -> Pattern {
match pat { match pat {
Pattern::Literal(v) => Expression::Literal(v.clone()), Pattern::Literal(v) => Pattern::Literal(v.clone()),
Pattern::Path(_, v) => Expression::Path(v.clone().into()), Pattern::Path(is_mut, v) => Pattern::Path(*is_mut, v.clone().into()),
Pattern::Tuple(items) => Expression::Literal(Literal::Tuple( _ => Pattern::Path(false, Path(vec![Identifier(format!("_{idx}"))])),
items.iter().map(|v| expr_pattern(&v)).collect(),
)),
Pattern::NamedTuple(path, items) => Expression::Fix {
initial: Box::new(Expression::Path(path.clone().into())),
prefixes: Vec::new(),
postfixes: vec![Postfix::Call(
items.iter().map(|v| expr_pattern(&v)).collect(),
)],
},
Pattern::Struct(_, _) => unimplemented!(),
} }
} }
crates/mist-api/src/builder.mist
+21 -21
View File
@@ -29,9 +29,9 @@ pub bool build(Vec<String> mut args, PathBuf root) {
args.remove(0); args.remove(0);
args.insert(1, "--message-format=json".to_string()); args.insert(1, "--message-format=json".to_string());
var is_root = root == env::current_dir().expect("Failed getting env"); let is_root = root == env::current_dir().expect("Failed getting env");
var mut command = Command::new("cargo") let mut command = Command::new("cargo")
.args(args) .args(args)
.stdout(Stdio::piped()) .stdout(Stdio::piped())
.stderr(Stdio::inherit()) .stderr(Stdio::inherit())
@@ -39,47 +39,47 @@ pub bool build(Vec<String> mut args, PathBuf root) {
.spawn() .spawn()
.expect("Failed to run cargo"); .expect("Failed to run cargo");
var mut reader = std::io::BufReader::new(command.stdout.take().expect("Failed to get reader")); let mut reader = std::io::BufReader::new(command.stdout.take().expect("Failed to get reader"));
var mut diagnostics = Vec::new(); let mut diagnostics = Vec::new();
var mut mapping = HashMap::new(); let mut mapping = HashMap::new();
var mist_src = format!(".mist{MAIN_SEPARATOR}src"); let mist_src = format!(".mist{MAIN_SEPARATOR}src");
for (message : cargo_metadata::Message::parse_stream(&mut reader)) { for (message : cargo_metadata::Message::parse_stream(&mut reader)) {
match (message) { match (message) {
Ok[Message::CompilerMessage[msg]] => { Ok[Message::CompilerMessage[msg]] => {
for (span : &msg.message.spans) { for (span : &msg.message.spans) {
if (span.is_primary) { if (span.is_primary) {
var rust_path = root.join(&span.file_name); let rust_path = root.join(&span.file_name);
var mist_file = span let mist_file = span
.file_name .file_name
.replacen(&mist_src, "src", 1) .replacen(&mist_src, "src", 1)
.trim_end_matches(".rs") .trim_end_matches(".rs")
.to_string() .to_string()
+ ".mist"; + ".mist";
var mist_path = root.join(&mist_file); let mist_path = root.join(&mist_file);
if (!fs::exists(&mist_path).expect("Unable to check if mist file exists")) { if (!fs::exists(&mist_path).expect("Unable to check if mist file exists")) {
diagnostics.push(MistDiagnostic::Rust(msg)); diagnostics.push(MistDiagnostic::Rust(msg));
break; break;
} }
var map = mapping.entry(rust_path.clone()).or_insert_with(|| { let map = mapping.entry(rust_path.clone()).or_insert_with(|| {
rev_mapper::get_mapping( rev_mapper::get_mapping(
&fs::read_to_string(rust_path) &fs::read_to_string(rust_path)
.expect("Failed to read file for mapping") .expect("Failed to read file for mapping")
) )
}); });
var [_, rev_mapper::MistMap[line, column]] = let [_, rev_mapper::MistMap[line, column]] =
rev_mapper::find_mapping(&map, &rev_mapper::RustMap(span.line_end, span.column_start)) rev_mapper::find_mapping(&map, &rev_mapper::RustMap(span.line_end, span.column_start))
.expect("Unable to find mapping"); .expect("Unable to find mapping");
var mist_msg = MistDiagnosticMessage { let mist_msg = MistDiagnosticMessage {
message: format!( message: format!(
"{}: {}", "{}: {}",
msg.message.message, msg.message.message,
@@ -113,11 +113,11 @@ pub bool build(Vec<String> mut args, PathBuf root) {
Ok[Message::BuildFinished[finish]] => { Ok[Message::BuildFinished[finish]] => {
print_diagnostics(&diagnostics); print_diagnostics(&diagnostics);
var mut raw_reader = reader.into_inner(); let mut raw_reader = reader.into_inner();
var mut stdout = std::io::stdout(); let mut stdout = std::io::stdout();
std::io::copy(&mut raw_reader, &mut stdout) std::io::copy(&mut raw_reader, &mut stdout)
.map_err(|var v| v.to_string()) .map_err(|let v| v.to_string())
.expect("(Mist) Failed to copy IO"); .expect("(Mist) Failed to copy IO");
command.wait().unwrap(); command.wait().unwrap();
@@ -134,12 +134,12 @@ pub bool build(Vec<String> mut args, PathBuf root) {
} }
pub void print_diagnostics(Vec<MistDiagnostic>* diagnostics) { pub void print_diagnostics(Vec<MistDiagnostic>* diagnostics) {
var mut files = HashMap::new(); let mut files = HashMap::new();
for (diag : diagnostics) { for (diag : diagnostics) {
match (diag) { match (diag) {
MistDiagnostic::Error[msg] => { MistDiagnostic::Error[msg] => {
var line = get_line(&mut files, &msg); let line = get_line(&mut files, &msg);
println!( println!(
"\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}", "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}",
@@ -152,7 +152,7 @@ pub void print_diagnostics(Vec<MistDiagnostic>* diagnostics) {
} }
MistDiagnostic::Warning[msg] => { MistDiagnostic::Warning[msg] => {
var line = get_line(&mut files, &msg); let line = get_line(&mut files, &msg);
println!( println!(
"\n{}:{}:{}\n \x1b[33mWarning\x1b[0m: {}\n\t{}", "\n{}:{}:{}\n \x1b[33mWarning\x1b[0m: {}\n\t{}",
@@ -173,9 +173,9 @@ pub Option<String> get_line(
HashMap<PathBuf, Vec<String>> mut* files, HashMap<PathBuf, Vec<String>> mut* files,
MistDiagnosticMessage* msg, MistDiagnosticMessage* msg,
) { ) {
var src_path = msg.file_path.clone(); let src_path = msg.file_path.clone();
var lines = files.entry(src_path.clone()).or_insert_with(|| { let lines = files.entry(src_path.clone()).or_insert_with(|| {
fs::read_to_string(src_path) fs::read_to_string(src_path)
.expect("Unable to read mist file") .expect("Unable to read mist file")
.lines() .lines()
@@ -184,5 +184,5 @@ pub Option<String> get_line(
.collect() .collect()
}); });
lines.get(msg.line - 1).map(|var v| v.trim().to_string()) lines.get(msg.line - 1).map(|let v| v.trim().to_string())
} }
crates/mist-api/src/modules.mist
+6 -6
View File
@@ -10,9 +10,9 @@ pub class Module {
pub Vec<Self> children; pub Vec<Self> children;
pub constructor(PathBuf mist_path) { pub constructor(PathBuf mist_path) {
self.children = new Vec(); self.children = Vec::new();
self.name = mist_path.file_stem() self.name = mist_path.file_stem()
.and_then(|var s| s.to_str()) .and_then(|let s| s.to_str())
.expect("Failed to get module name") .expect("Failed to get module name")
.to_string(); .to_string();
self.path = mist_path; self.path = mist_path;
@@ -30,7 +30,7 @@ pub class Module {
} }
void scan_directory(self mut*, Path* search_dir) { void scan_directory(self mut*, Path* search_dir) {
var entries = match (fs::read_dir(search_dir)) { let entries = match (fs::read_dir(search_dir)) {
Ok[entries] => entries; Ok[entries] => entries;
Err[e] => { Err[e] => {
eprintln!("error: failed to read directory {}\n {}", search_dir.display(), e); eprintln!("error: failed to read directory {}\n {}", search_dir.display(), e);
@@ -39,7 +39,7 @@ pub class Module {
}; };
for (entry : entries) { for (entry : entries) {
var entry = match (entry) { let entry = match (entry) {
Ok[entry] => entry; Ok[entry] => entry;
Err[e] => { Err[e] => {
eprintln!("error: failed to read directory entry\n {}", e); eprintln!("error: failed to read directory entry\n {}", e);
@@ -53,7 +53,7 @@ pub class Module {
continue; continue;
} }
self.children.push(new Module(child_path)); self.children.push(Module::new(child_path));
} }
} }
@@ -75,7 +75,7 @@ pub class Module {
} }
pub Module master_package(PathBuf mist_path) { pub Module master_package(PathBuf mist_path) {
var mut root_mod = new Module(mist_path.clone()); let mut root_mod = Module::new(mist_path.clone());
Path* parent_dir = mist_path.parent() Path* parent_dir = mist_path.parent()
.expect("Failed to get parent directory of root file"); .expect("Failed to get parent directory of root file");
crates/mist-api/src/transpiler.mist
+13 -13
View File
@@ -8,18 +8,18 @@ use <mist_parser::error>;
use <crate::modules>; use <crate::modules>;
pub PathBuf transpile() { pub PathBuf transpile() {
var start = time::Instant::now(); let start = time::Instant::now();
var root = env::current_dir().expect("Unable to find project root"); let root = env::current_dir().expect("Unable to find project root");
PathBuf src = root.join("src"); PathBuf src = root.join("src");
PathBuf out = root.join(".mist/src"); PathBuf out = root.join(".mist/src");
var master = modules::master_package(src.join("main.mist")); let master = modules::master_package(src.join("main.mist"));
master.transpile(&out); master.transpile(&out);
var elapsed = start.elapsed(); let elapsed = start.elapsed();
println!( println!(
"\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m", "\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m",
@@ -31,9 +31,9 @@ pub PathBuf transpile() {
impl modules::Module { impl modules::Module {
String transpile(self*, PathBuf* parent_dir) { String transpile(self*, PathBuf* parent_dir) {
if (!self.path.is_dir() && self.path.extension().and_then(|var v| v.to_str()) != Some("mist")) { if (!self.path.is_dir() && self.path.extension().and_then(|let v| v.to_str()) != Some("mist")) {
var file_name = self.path.file_name() let file_name = self.path.file_name()
.and_then(|var s| s.to_str()) .and_then(|let s| s.to_str())
.expect("Failed to get file name"); .expect("Failed to get file name");
fs::copy(&self.path, parent_dir.join(&file_name)).expect("Failed to copy SideFile"); fs::copy(&self.path, parent_dir.join(&file_name)).expect("Failed to copy SideFile");
@@ -44,7 +44,7 @@ impl modules::Module {
PathBuf dir = self.output_dir(&parent_dir); PathBuf dir = self.output_dir(&parent_dir);
PathBuf output_file = self.output_path(&parent_dir); PathBuf output_file = self.output_path(&parent_dir);
var _ = fs::create_dir_all(&dir); let _ = fs::create_dir_all(&dir);
String mut output = String::new(); String mut output = String::new();
@@ -57,7 +57,7 @@ impl modules::Module {
return String::new(); return String::new();
} }
var res = fs::write(&output_file, output); let res = fs::write(&output_file, output);
if (res.is_err()) { if (res.is_err()) {
eprintln!( eprintln!(
@@ -86,16 +86,16 @@ void transpile_file(PathBuf* path, PathBuf* output_file, str* mod_decl) {
} }
}; };
var mut gc = mist_codegen::RustCodegen::new(); let mut gc = mist_codegen::RustCodegen::new();
String output = gc.generate(match (mist_parser::parse(&source)) { String output = gc.generate(match (mist_parser::parse(&source)) {
Ok[ast] => ast; Ok[ast] => ast;
Err[e] => { Err[e] => {
match (e) { match (e) {
error::ParseError::Ast[e] => { error::ParseError::Ast[e] => {
var start_pos = e.span.start_pos().line_col(); let start_pos = e.span.start_pos().line_col();
var span = e.span.as_str(); let span = e.span.as_str();
eprintln!( eprintln!(
"\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}{}\t{}", "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}{}\t{}",
@@ -120,7 +120,7 @@ void transpile_file(PathBuf* path, PathBuf* output_file, str* mod_decl) {
} }
}); });
var res = fs::write(&output_file, format!("{mod_decl}{output}")); let res = fs::write(&output_file, format!("{mod_decl}{output}"));
if (res.is_err()) { if (res.is_err()) {
eprintln!( eprintln!(
crates/parser/src/ast/expr.rs
+2 -1
View File
@@ -33,10 +33,11 @@ pub enum Literal {
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub enum Pattern { pub enum Pattern {
NamedTuple(Path, Vec<Box<Pattern>>), NamedTuple(Path, Vec<Box<Pattern>>),
Struct(Path, Vec<Box<Pattern>>), Struct(Path, Vec<Option<(Identifier, Option<Box<Pattern>>)>>),
Tuple(Vec<Box<Pattern>>), Tuple(Vec<Box<Pattern>>),
Literal(Literal), Literal(Literal),
Path(bool, Path), Path(bool, Path),
Etc,
} }
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
crates/parser/src/grammar.pest
+10 -4
View File
@@ -134,20 +134,26 @@ literal = {
// PATTERNS // PATTERNS
// ====================================================== // ======================================================
etc_pattern = { ".." }
multi_pat_template = _{ multi_pat_template = _{
(pattern ~ ("," ~ pattern)*)? ((pattern | etc_pattern) ~ ("," ~ (pattern | etc_pattern))*)?
} }
tuple_pattern = { tuple_pattern = {
"[" ~ pattern ~ "," ~ multi_pat_template ~ "]" "[" ~ (pattern | etc_pattern) ~ "," ~ multi_pat_template ~ "]"
} }
named_tuple_pattern = { named_tuple_pattern = {
static_path ~ "[" ~ multi_pat_template ~ "]" static_path ~ "[" ~ multi_pat_template ~ "]"
} }
struct_destruct = {
identifier ~ (":" ~ pattern)?
}
struct_pattern = { struct_pattern = {
static_path ~ "{" ~ multi_pat_template ~ "}" static_path ~ "{" ~ ((struct_destruct | etc_pattern) ~ ("," ~ (struct_destruct | etc_pattern))*)? ~ "}"
} }
path_pattern = { path_pattern = {
@@ -210,7 +216,7 @@ param_list = {
// ====================================================== // ======================================================
import = { import = {
visibility? ~ "use" ~ "<" ~ static_path ~ ">" ~ semicolon visibility? ~ "use" ~ static_path ~ semicolon
} }
mod_package = { mod_package = {
crates/parser/src/lib.rs
+8
View File
@@ -77,6 +77,14 @@ macro_rules! ast_expr {
analyzer.build(v) analyzer.build(v)
}}; }};
(( $($v:expr),* $(,)? )) => {{
let mut analyzer = $crate::error::AstErrorAnalyzer(None);
let v = ( $(analyzer.get($v).get()?),* );
analyzer.build(v)
}};
($($item:ident)::+) => { ($($item:ident)::+) => {
$($item)::+ $($item)::+
}; };
crates/parser/src/parser/common/mod.rs
+17 -1
View File
@@ -71,7 +71,21 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Pattern {
Rule::struct_pattern => ast_expr!(Pattern::Struct( Rule::struct_pattern => ast_expr!(Pattern::Struct(
Path::try_from(inner.next().unwrap()), Path::try_from(inner.next().unwrap()),
collect_recovered_map(inner, |v| Self::try_from(v).map(Box::new)), collect_recovered_map(inner, |v| {
if v.as_rule() == Rule::etc_pattern {
return Ok(None);
}
let mut inner = dbg!(v).into_inner();
Some(ast_expr!((
Identifier::try_from(inner.next().unwrap()),
inner
.next()
.map(|v| Self::try_from(v).map(Box::new).get_map(Box::new))
.transpose()
)))
.transpose()
}),
)), )),
Rule::literal => ast_expr!(Pattern::Literal(pair.try_into())), Rule::literal => ast_expr!(Pattern::Literal(pair.try_into())),
@@ -81,6 +95,8 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Pattern {
inner.next().unwrap().try_into() inner.next().unwrap().try_into()
)), )),
Rule::etc_pattern => Ok(Pattern::Etc),
_ => AstError::bug_unimplemented(pair), _ => AstError::bug_unimplemented(pair),
} }
} }
mist-test/src/main.mist
-4
View File
@@ -1,7 +1,3 @@
class Bro {
constructor([str*, str*] [idk, bro]) {}
}
void main() { void main() {
test_package::hello(); test_package::hello();
} }
src/main.mist
+2 -2
View File
@@ -14,7 +14,7 @@ void main() {
match (args[1].as_str()) { match (args[1].as_str()) {
"run" | "build" | "check" | "r" | "b" | "c" => { "run" | "build" | "check" | "r" | "b" | "c" => {
var root = transpiler::transpile(); let root = transpiler::transpile();
println!(""); println!("");
@@ -69,7 +69,7 @@ void print_usage() {
void init_project(Vec<String> mut args) { void init_project(Vec<String> mut args) {
args.remove(0); args.remove(0);
new process::Command("cargo") process::Command::new("cargo")
.args(args) .args(args)
.stdout(process::Stdio::inherit()) .stdout(process::Stdio::inherit())
.stderr(process::Stdio::inherit()) .stderr(process::Stdio::inherit())