Merge pull request #196 from JSAbrahams/v0.2.2

V0.2.2

Author: JSAbrahams

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mamba"
-version = "0.2.1"
+version = "0.2.2"
 authors = ["Joel Abrahams <abrahamsjo@gmail.com>"]
 description = "A transpiler which translates Mamba to Python 3 files"
 edition = "2018"
@@ -23,3 +23,4 @@ clap = {version = "2.33", features = ["yaml"]}
 leg = "0.1.3"
 pathdiff = "0.1.0"
 glob = "0.3.0"
+itertools = "0.8.2"

Cargo.toml

@@ -77,6 +77,9 @@ pub enum Core {
         num: String,
         exp: String
     },
+    DocStr {
+        _str: String
+    },
     Str {
         _str: String
     },

src/core/construct.rs

@@ -53,6 +53,7 @@ fn to_py(core: &Core, ind: usize) -> String {
                 format!("{}[{}]", lit, comma_delimited(generics, ind))
             },
         Core::IdType { lit, ty } => format!("{}: {}", lit, to_py(ty, ind)),
+        Core::DocStr { _str } => format!("\"\"\"{}\"\"\"", _str),
         Core::Str { _str } => format!("\"{}\"", _str),
         Core::FStr { _str } => format!("f\"{}\"", _str),
         Core::Int { int } => int.clone(),

src/core/mod.rs

@@ -17,6 +17,10 @@ pub fn desugar_call(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
             function: Box::from(desugar_node(name, imp, state)?),
             args:     desugar_vec(args, imp, state)?
         },
+        Node::ConstructorCall { name, args } => Core::FunctionCall {
+            function: Box::from(desugar_node(name, imp, &state.is_constructor(true))?),
+            args:     desugar_vec(args, imp, state)?
+        },
         other => panic!("Expected call flow but was: {:?}.", other)
     })
 }

src/desugar/call.rs

@@ -108,7 +108,7 @@ pub fn desugar_class(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResu
                             _ => false
                         });
                     stmts.append(&mut non_variables);
-                    final_definitions = stmts.clone();
+                    final_definitions = stmts;
 
                     Core::ClassDef {
                         name:        Box::from(desugar_node(id, imp, state)?),

src/desugar/class.rs

@@ -21,7 +21,7 @@ pub fn desugar_definition(ast: &AST, imp: &mut Imports, state: &State) -> Desuga
             Core::VarDef {
                 private: *private,
                 id:      Box::from(id.clone()),
-                right:   match (id.clone(), expression) {
+                right:   match (id, expression) {
                     (_, Some(expr)) => Box::from(desugar_node(&expr, imp, &state)?),
                     (Core::Tuple { elements }, None) =>
                         Box::from(Core::Tuple { elements: vec![Core::None; elements.len()] }),

src/desugar/definition.rs

@@ -11,6 +11,7 @@ use crate::desugar::state::State;
 use crate::desugar::ty::desugar_type;
 use crate::parser::ast::Node;
 use crate::parser::ast::AST;
+use crate::type_checker::context::ty::concrete::concrete_to_python;
 
 // TODO return imports instead of modifying mutable reference
 pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResult {
@@ -48,6 +49,7 @@ pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
             num: num.clone(),
             exp: if exp.is_empty() { String::from("0") } else { exp.clone() }
         },
+        Node::DocStr { lit } => Core::DocStr { _str: lit.clone() },
         Node::Str { lit, expressions } =>
             if expressions.is_empty() {
                 Core::Str { _str: lit.clone() }
@@ -70,7 +72,9 @@ pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
 
         Node::Undefined => Core::None,
         Node::IdType { .. } => desugar_type(ast, imp, state)?,
-        Node::Id { lit } => Core::Id { lit: lit.clone() },
+        Node::Id { lit } => Core::Id {
+            lit: if state.is_constructor { concrete_to_python(lit) } else { lit.clone() }
+        },
         Node::_Self => Core::Id { lit: String::from("self") },
         Node::Init => Core::Id { lit: String::from("init") },
         Node::Bool { lit } => Core::Bool { _bool: *lit },
@@ -215,7 +219,8 @@ pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
             }
         },
 
-        Node::FunctionCall { .. } | Node::PropertyCall { .. } => desugar_call(ast, imp, state)?,
+        Node::FunctionCall { .. } | Node::PropertyCall { .. } | Node::ConstructorCall { .. } =>
+            desugar_call(ast, imp, state)?,
 
         Node::AnonFun { args, body } => Core::AnonFun {
             args: desugar_vec(args, imp, &state.expand_ty(false))?,
@@ -249,12 +254,9 @@ pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
         },
         Node::Script { statements } =>
             Core::Block { statements: desugar_vec(statements, imp, state)? },
-        Node::File { modules, imports, .. } => {
-            let mut imports = desugar_vec(imports, imp, state)?;
+        Node::File { modules, .. } => {
             let mut modules = desugar_vec(modules, imp, state)?;
-            imports.append(&mut imp.imports.clone().into_iter().collect());
-
-            let mut statements = imports;
+            let mut statements = imp.imports.clone();
             statements.append(&mut modules);
             Core::Block { statements }
         }
@@ -290,7 +292,6 @@ pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
         Node::Step { .. } => panic!("Step cannot be top level."),
         Node::Raises { expr_or_stmt, .. } => desugar_node(expr_or_stmt, imp, state)?,
         Node::Raise { error } => Core::Raise { error: Box::from(desugar_node(error, imp, state)?) },
-        Node::Retry { .. } => return Err(UnimplementedErr::new(ast, "retry")),
 
         Node::Handle { expr_or_stmt, cases } => {
             let assign_to = if let Node::VariableDef { id_maybe_type, .. } = &expr_or_stmt.node {
@@ -351,7 +352,7 @@ pub fn desugar_node(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
     let core = if let Some(assign_to) = assign_to {
         match core {
             Core::Block { .. } | Core::Return { .. } => core,
-            expr => Core::Assign { left: Box::from(assign_to), right: Box::from(expr.clone()) }
+            expr => Core::Assign { left: Box::from(assign_to), right: Box::from(expr) }
         }
     } else {
         core

src/desugar/node.rs

@@ -3,21 +3,28 @@ use crate::core::construct::Core;
 // TODO remove expect_expr once type checker augments AST
 #[derive(Clone, Debug)]
 pub struct State {
-    pub tup:       usize,
+    pub tup: usize,
     pub interface: bool,
     pub expand_ty: bool,
+    pub is_constructor: bool,
     pub assign_to: Option<Core>
 }
 
 impl State {
-    pub fn new() -> State { State { tup: 1, interface: false, expand_ty: true, assign_to: None } }
+    pub fn new() -> State {
+        State { tup: 1, interface: false, expand_ty: true, assign_to: None, is_constructor: false }
+    }
 
     pub fn in_tup(&self, tup: usize) -> State { State { tup, ..self.clone() } }
 
     pub fn in_interface(&self, interface: bool) -> State { State { interface, ..self.clone() } }
 
     pub fn expand_ty(&self, expand_ty: bool) -> State { State { expand_ty, ..self.clone() } }
 
+    pub fn is_constructor(&self, is_constructor: bool) -> State {
+        State { is_constructor, ..self.clone() }
+    }
+
     pub fn assign_to(&self, assign_to: Option<&Core>) -> State {
         State { assign_to: assign_to.cloned(), ..self.clone() }
     }

src/desugar/state.rs

@@ -27,10 +27,22 @@ pub fn desugar_type(ast: &AST, imp: &mut Imports, state: &State) -> DesugarResul
                             ty:  Box::from(desugar_node(ty, imp, state)?)
                         }
                     } else {
-                        Core::Id { lit: lit.clone() }
+                        Core::Id {
+                            lit: if state.is_constructor {
+                                concrete_to_python(lit)
+                            } else {
+                                lit.clone()
+                            }
+                        }
                     }
                 } else {
-                    Core::Id { lit: lit.clone() }
+                    Core::Id {
+                        lit: if state.is_constructor {
+                            concrete_to_python(lit)
+                        } else {
+                            lit.clone()
+                        }
+                    }
                 },
             Node::_Self => Core::Id { lit: String::from("self") },
             _ => desugar_node(id, imp, state)?