Identifier in ASt

src/codegen.rs

@@ -1,7 +1,7 @@
 use parser::ast::{
-    Attribute, BinaryOp, Block, Expression, FunctionDecl, Literal, Path, Postfix, Prefix,
-    Statement, StatementBranch, TopLevel, TopLevelKind, TypeExpr, TypeExprKind, TypePostfix,
-    VarAssignStmt, VarDecl, VarDeclStmt, Visibility,
+    Attribute, BinaryOp, Block, Expression, FunctionDecl, Identifier, Literal, Path, Postfix,
+    Prefix, Statement, StatementBranch, TopLevel, TopLevelKind, TypeExpr, TypeExprKind,
+    TypePostfix, VarAssignStmt, VarDecl, VarDeclStmt, Visibility,
 };
 
 // ---------------------------------------------------------------------------
@@ -197,7 +197,7 @@ impl GetRust for Option<&Vec<Prefix>> {
 impl GetRust for Postfix {
     fn get_rust(&self) -> String {
         match self {
-            Postfix::FieldAccess(field) => format!(".{}", field),
+            Postfix::FieldAccess(field) => format!(".{}", field.get_rust()),
 
             Postfix::Call(args) => {
                 let args = args
@@ -215,7 +215,7 @@ impl GetRust for Postfix {
             Postfix::StructCall(fields) => {
                 let fields = fields
                     .iter()
-                    .map(|(k, v)| format!("{}: {}", k, v.get_rust()))
+                    .map(|(k, v)| format!("{}: {}", k.get_rust(), v.get_rust()))
                     .collect::<Vec<_>>()
                     .join(", ");
                 format!("{{ {} }}", fields)
@@ -309,19 +309,19 @@ impl ToRust for TopLevelKind {
         match self {
             Self::ModAttribute => {}
             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::StructDecl {
                 visibility,
                 name,
                 fields,
             } => {
-                cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name));
+                cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name.get_rust()));
                 cg.indent += 1;
 
                 for (field_name, _, ty) in &fields.0 {
                     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;
@@ -335,19 +335,19 @@ impl ToRust for TopLevelKind {
                 methods,
             } => {
                 // Struct decl
-                cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name));
+                cg.addln(&format!("{}struct {} {{", visibility.get_rust(), name.get_rust()));
                 cg.indent += 1;
 
                 for field in fields {
                     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.addln("}\n");
 
                 // Constructor
-                cg.addln(&format!("impl {} {{", name));
+                cg.addln(&format!("impl {} {{", name.get_rust()));
                 cg.indent += 1;
 
                 let params_str = constructor
@@ -371,7 +371,7 @@ impl ToRust for TopLevelKind {
                     if let Some(init) = &field.init {
                         cg.add_indentedln(&format!(
                             "this.{} = {};",
-                            field.decl.name,
+                            field.decl.name.get_rust(),
                             init.get_rust()
                         ));
                     }
@@ -383,7 +383,7 @@ impl ToRust for TopLevelKind {
                         .params
                         .0
                         .iter()
-                        .map(|e| e.name.to_string())
+                        .map(|e| e.name.get_rust())
                         .collect::<Vec<_>>()
                         .join(", ")
                 ));
@@ -501,7 +501,7 @@ impl ToRust for Statement {
                 iterator,
                 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);
             }
 
@@ -529,7 +529,7 @@ impl ToRust for FunctionDecl {
         cg.add_indentedln(&format!(
             "{}fn {}({}) -> {} {{",
             self.visibility.get_rust(),
-            self.name,
+            self.name.get_rust(),
             params_str,
             self.return_type.get_rust()
         ));
@@ -550,13 +550,13 @@ impl GetRust for VarDecl {
             .map(|t| format!(": {}", t.get_rust()))
             .unwrap_or_default();
 
-        format!("{}{}{}", mutability, self.name, ty)
+        format!("{}{}{}", mutability, self.name.get_rust(), ty)
     }
 }
 
 impl GetRust for Path {
     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 {
     let rust_path = path.get_rust();