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

Identifier in ASt

Browse Source
This commit is contained in:
selimaj-dev
2026-05-07 18:54:07 +02:00
parent c6e34bbc70
commit a9fdfe4100
3 changed files with 55 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
parser/src/ast.rs
+13 -10
View File
@@ -1,7 +1,10 @@
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub struct FieldList(pub Vec<(String, Visibility, TypeExpr)>); pub struct Identifier(pub String);
#[derive(Debug, Clone, Serialize)]
pub struct FieldList(pub Vec<(Identifier, Visibility, TypeExpr)>);
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub struct ParamList(pub Vec<VarDecl>); pub struct ParamList(pub Vec<VarDecl>);
@@ -44,7 +47,7 @@ pub enum TypeExprKind {
pub struct TypeExpr(pub TypeExprKind, pub Vec<TypePostfix>); pub struct TypeExpr(pub TypeExprKind, pub Vec<TypePostfix>);
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub struct Path(pub Vec<String>); pub struct Path(pub Vec<Identifier>);
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub enum BinaryOp { pub enum BinaryOp {
@@ -68,16 +71,16 @@ pub struct TopLevel(pub TopLevelKind, pub Vec<Attribute>);
pub enum TopLevelKind { pub enum TopLevelKind {
ModAttribute, ModAttribute,
Import(Path), Import(Path),
Mod(String), Mod(Identifier),
StructDecl { StructDecl {
visibility: Visibility, visibility: Visibility,
name: String, name: Identifier,
fields: FieldList, fields: FieldList,
}, },
FunctionDecl(FunctionDecl), FunctionDecl(FunctionDecl),
ClassDecl { ClassDecl {
visibility: Visibility, visibility: Visibility,
name: String, name: Identifier,
fields: Vec<VarDeclStmt>, fields: Vec<VarDeclStmt>,
constructor: ClassConstructor, constructor: ClassConstructor,
methods: Vec<FunctionDecl>, methods: Vec<FunctionDecl>,
@@ -94,7 +97,7 @@ pub struct ClassConstructor {
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub struct FunctionDecl { pub struct FunctionDecl {
pub visibility: Visibility, pub visibility: Visibility,
pub name: String, pub name: Identifier,
pub params: ParamList, pub params: ParamList,
pub return_type: TypeExpr, pub return_type: TypeExpr,
pub body: Block, pub body: Block,
@@ -102,10 +105,10 @@ pub struct FunctionDecl {
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub enum Postfix { pub enum Postfix {
FieldAccess(String), FieldAccess(Identifier),
Call(Vec<Expression>), Call(Vec<Expression>),
MacroCall(String), MacroCall(String),
StructCall(Vec<(String, Expression)>), StructCall(Vec<(Identifier, Expression)>),
Index(Expression), Index(Expression),
Binary(BinaryOp, Expression), Binary(BinaryOp, Expression),
} }
@@ -139,7 +142,7 @@ pub enum Statement {
body: Box<Statement>, body: Box<Statement>,
}, },
For { For {
pattern: String, pattern: Identifier,
iterator: Expression, iterator: Expression,
body: Box<Statement>, body: Box<Statement>,
}, },
@@ -152,7 +155,7 @@ pub enum Statement {
#[derive(Debug, Clone, Serialize)] #[derive(Debug, Clone, Serialize)]
pub struct VarDecl { pub struct VarDecl {
pub mutable: bool, pub mutable: bool,
pub name: String, pub name: Identifier,
pub type_: Option<TypeExpr>, pub type_: Option<TypeExpr>,
} }
parser/src/lib.rs
+19 -16
View File
@@ -84,7 +84,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for TypeExprKind {
impl From<pest::iterators::Pair<'_, Rule>> for Path { impl From<pest::iterators::Pair<'_, Rule>> for Path {
fn from(pair: pest::iterators::Pair<'_, Rule>) -> Self { fn from(pair: pest::iterators::Pair<'_, Rule>) -> Self {
match pair.as_rule() { match pair.as_rule() {
Rule::static_path => Path(pair.into_inner().map(|i| i.as_str().to_string()).collect()), Rule::static_path => Path(pair.into_inner().map(Identifier::from).collect()),
_ => unimplemented!("{pair:#?}"), _ => unimplemented!("{pair:#?}"),
} }
} }
@@ -98,7 +98,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for FieldList {
let mut param_inner = p.into_inner(); let mut param_inner = p.into_inner();
let visibility = Visibility::from(&mut param_inner); let visibility = Visibility::from(&mut param_inner);
let param_type = TypeExpr::from(param_inner.next().unwrap()); let param_type = TypeExpr::from(param_inner.next().unwrap());
let param_name = param_inner.next().unwrap().as_str().to_string(); let param_name = Identifier::from(param_inner.next().unwrap());
(param_name, visibility, param_type) (param_name, visibility, param_type)
}) })
.collect(); .collect();
@@ -235,7 +235,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for TopLevelKind {
Rule::struct_decl => { Rule::struct_decl => {
let visibility = Visibility::from(&mut inner); let visibility = Visibility::from(&mut inner);
let name = inner.next().unwrap().as_str().to_string(); let name = Identifier::from(inner.next().unwrap());
let fields_pair = inner.next().unwrap(); let fields_pair = inner.next().unwrap();
let fields = FieldList::from(fields_pair); let fields = FieldList::from(fields_pair);
@@ -248,7 +248,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for TopLevelKind {
Rule::class_decl => TopLevelKind::ClassDecl { Rule::class_decl => TopLevelKind::ClassDecl {
visibility: Visibility::from(&mut inner), visibility: Visibility::from(&mut inner),
name: inner.next().unwrap().as_str().to_string(), name: Identifier::from(inner.next().unwrap()),
fields: inner fields: inner
.next() .next()
.unwrap() .unwrap()
@@ -259,7 +259,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for TopLevelKind {
methods: inner.into_iter().map(FunctionDecl::from).collect(), methods: inner.into_iter().map(FunctionDecl::from).collect(),
}, },
Rule::mod_package => TopLevelKind::Mod(inner.next().unwrap().as_str().to_string()), Rule::mod_package => TopLevelKind::Mod(Identifier::from(inner.next().unwrap())),
_ => unimplemented!("{rule:#?}"), _ => unimplemented!("{rule:#?}"),
} }
@@ -331,7 +331,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for Statement {
}, },
Rule::for_stmt => Statement::For { Rule::for_stmt => Statement::For {
pattern: inner.next().unwrap().as_str().to_string(), pattern: Identifier::from(inner.next().unwrap()),
iterator: inner.next().unwrap().into(), iterator: inner.next().unwrap().into(),
body: Box::new(Statement::from(inner.next().unwrap())), body: Box::new(Statement::from(inner.next().unwrap())),
}, },
@@ -419,10 +419,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for Postfix {
match rule { match rule {
Rule::postfix => Postfix::from(inner.next().unwrap()), Rule::postfix => Postfix::from(inner.next().unwrap()),
Rule::field_px => { Rule::field_px => Postfix::FieldAccess(Identifier::from(inner.next().unwrap())),
let field_name = inner.next().unwrap().as_str().to_string();
Postfix::FieldAccess(field_name)
}
Rule::call_px => Postfix::Call(inner.map(Expression::from).collect()), Rule::call_px => Postfix::Call(inner.map(Expression::from).collect()),
@@ -431,7 +428,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for Postfix {
.map(|p| { .map(|p| {
let mut pi = p.into_inner(); let mut pi = p.into_inner();
( (
pi.next().unwrap().as_str().to_string(), Identifier::from(pi.next().unwrap()),
Expression::from(pi.next().unwrap()), Expression::from(pi.next().unwrap()),
) )
}) })
@@ -502,7 +499,7 @@ impl From<pest::iterators::Pair<'_, Rule>> for VarDecl {
}); });
let mutable = listen_rule(&mut inner, Rule::mutable); let mutable = listen_rule(&mut inner, Rule::mutable);
let name = inner.next().unwrap().as_str().to_string(); let name = Identifier::from(inner.next().unwrap());
VarDecl { VarDecl {
mutable, mutable,
@@ -524,10 +521,10 @@ impl From<pest::iterators::Pair<'_, Rule>> for FunctionDecl {
let return_type = TypeExpr::from(inner.next().unwrap()); let return_type = TypeExpr::from(inner.next().unwrap());
let name = inner.next().unwrap().as_str().to_string(); let name = Identifier::from(inner.next().unwrap());
let self_param = consume_rule(&mut inner, Rule::self_param).map(|param| { let self_param = consume_rule(&mut inner, Rule::self_param).map(|param| {
let mut param_inner = param.into_inner(); let mut param_inner = param.into_inner();
let name = format!("self"); let name = Identifier(String::from("self"));
let mutable = listen_rule(&mut param_inner, Rule::mutable); let mutable = listen_rule(&mut param_inner, Rule::mutable);
@@ -535,9 +532,9 @@ impl From<pest::iterators::Pair<'_, Rule>> for FunctionDecl {
VarDecl { VarDecl {
mutable: mutable && !is_ref, mutable: mutable && !is_ref,
name, name: name.clone(),
type_: Some(TypeExpr( type_: Some(TypeExpr(
TypeExprKind::Path(Path(vec![format!("Self")])), TypeExprKind::Path(Path(vec![name])),
if is_ref { if is_ref {
vec![if mutable { vec![if mutable {
TypePostfix::RefMut TypePostfix::RefMut
@@ -610,3 +607,9 @@ pub fn consume_rule<'a>(
if consumed { pairs.next() } else { None } if consumed { pairs.next() } else { None }
} }
impl From<pest::iterators::Pair<'_, Rule>> for Identifier {
fn from(pair: pest::iterators::Pair<'_, Rule>) -> Self {
Identifier(pair.as_str().to_string())
}
}
src/codegen.rs
+23 -17
View File
@@ -1,7 +1,7 @@
use parser::ast::{ use parser::ast::{
Attribute, BinaryOp, Block, Expression, FunctionDecl, Literal, Path, Postfix, Prefix, Attribute, BinaryOp, Block, Expression, FunctionDecl, Identifier, Literal, Path, Postfix,
Statement, StatementBranch, TopLevel, TopLevelKind, TypeExpr, TypeExprKind, TypePostfix, Prefix, Statement, StatementBranch, TopLevel, TopLevelKind, TypeExpr, TypeExprKind,
VarAssignStmt, VarDecl, VarDeclStmt, Visibility, TypePostfix, VarAssignStmt, VarDecl, VarDeclStmt, Visibility,
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@@ -197,7 +197,7 @@ impl GetRust for Option<&Vec<Prefix>> {
impl GetRust for Postfix { impl GetRust for Postfix {
fn get_rust(&self) -> String { fn get_rust(&self) -> String {
match self { match self {
Postfix::FieldAccess(field) => format!(".{}", field), Postfix::FieldAccess(field) => format!(".{}", field.get_rust()),
Postfix::Call(args) => { Postfix::Call(args) => {
let args = args let args = args
@@ -215,7 +215,7 @@ impl GetRust for Postfix {
Postfix::StructCall(fields) => { Postfix::StructCall(fields) => {
let fields = fields let fields = fields
.iter() .iter()
.map(|(k, v)| format!("{}: {}", k, v.get_rust())) .map(|(k, v)| format!("{}: {}", k.get_rust(), v.get_rust()))
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", "); .join(", ");
format!("{{ {} }}", fields) format!("{{ {} }}", fields)
@@ -309,19 +309,19 @@ impl ToRust for TopLevelKind {
match self { match self {
Self::ModAttribute => {} Self::ModAttribute => {}
Self::Import(path) => cg.addln(&format!("use {};", path.get_rust())), Self::Import(path) => cg.addln(&format!("use {};", path.get_rust())),
Self::Mod(id) => cg.addln(&format!("mod {};", id)), Self::Mod(id) => cg.addln(&format!("mod {};", id.get_rust())),
Self::FunctionDecl(decl) => decl.to_rust(cg), Self::FunctionDecl(decl) => decl.to_rust(cg),
Self::StructDecl { Self::StructDecl {
visibility, visibility,
name, name,
fields, fields,
} => { } => {
cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name)); cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name.get_rust()));
cg.indent += 1; cg.indent += 1;
for (field_name, _, ty) in &fields.0 { for (field_name, _, ty) in &fields.0 {
let ty = ty.get_rust(); let ty = ty.get_rust();
cg.add_indentedln(&format!("pub {}: {},", field_name, ty)); cg.add_indentedln(&format!("pub {}: {},", field_name.get_rust(), ty));
} }
cg.indent -= 1; cg.indent -= 1;
@@ -335,19 +335,19 @@ impl ToRust for TopLevelKind {
methods, methods,
} => { } => {
// Struct decl // Struct decl
cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name)); cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name.get_rust()));
cg.indent += 1; cg.indent += 1;
for field in fields { for field in fields {
let ty = field.decl.type_.clone().unwrap().get_rust(); let ty = field.decl.type_.clone().unwrap().get_rust();
cg.add_indentedln(&format!("pub {}: {},", field.decl.name, ty)); cg.add_indentedln(&format!("pub {}: {},", field.decl.name.get_rust(), ty));
} }
cg.indent -= 1; cg.indent -= 1;
cg.addln("}\n"); cg.addln("}\n");
// Constructor // Constructor
cg.addln(&format!("impl {} {{", name)); cg.addln(&format!("impl {} {{", name.get_rust()));
cg.indent += 1; cg.indent += 1;
let params_str = constructor let params_str = constructor
@@ -371,7 +371,7 @@ impl ToRust for TopLevelKind {
if let Some(init) = &field.init { if let Some(init) = &field.init {
cg.add_indentedln(&format!( cg.add_indentedln(&format!(
"this.{} = {};", "this.{} = {};",
field.decl.name, field.decl.name.get_rust(),
init.get_rust() init.get_rust()
)); ));
} }
@@ -383,7 +383,7 @@ impl ToRust for TopLevelKind {
.params .params
.0 .0
.iter() .iter()
.map(|e| e.name.to_string()) .map(|e| e.name.get_rust())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(", ") .join(", ")
)); ));
@@ -501,7 +501,7 @@ impl ToRust for Statement {
iterator, iterator,
body, body,
} => { } => {
cg.add_indentedln(&format!("for {} in {}", pattern, iterator.get_rust())); cg.add_indentedln(&format!("for {} in {}", pattern.get_rust(), iterator.get_rust()));
cg.ensure_brackets(body); cg.ensure_brackets(body);
} }
@@ -529,7 +529,7 @@ impl ToRust for FunctionDecl {
cg.add_indentedln(&format!( cg.add_indentedln(&format!(
"{}fn {}({}) -> {} {{", "{}fn {}({}) -> {} {{",
self.visibility.get_rust(), self.visibility.get_rust(),
self.name, self.name.get_rust(),
params_str, params_str,
self.return_type.get_rust() self.return_type.get_rust()
)); ));
@@ -550,13 +550,13 @@ impl GetRust for VarDecl {
.map(|t| format!(": {}", t.get_rust())) .map(|t| format!(": {}", t.get_rust()))
.unwrap_or_default(); .unwrap_or_default();
format!("{}{}{}", mutability, self.name, ty) format!("{}{}{}", mutability, self.name.get_rust(), ty)
} }
} }
impl GetRust for Path { impl GetRust for Path {
fn get_rust(&self) -> String { fn get_rust(&self) -> String {
self.0.join("::") self.0.iter().map(Identifier::get_rust).collect::<Vec<String>>().join("::")
} }
} }
@@ -579,6 +579,12 @@ impl GetRust for Visibility {
} }
} }
impl GetRust for Identifier {
fn get_rust(&self) -> String {
self.0.clone()
}
}
pub fn get_static_type_path(path: &Path) -> String { pub fn get_static_type_path(path: &Path) -> String {
let rust_path = path.get_rust(); let rust_path = path.get_rust();