Merge pull request #198 from JSAbrahams/v0.3.0

V0.3.0

Author: JSAbrahams

Cargo.lock

@@ -1,8 +1,8 @@
 [package]
 name = "mamba"
-version = "0.2.2"
-authors = ["Joel Abrahams <abrahamsjo@gmail.com>"]
-description = "A transpiler which translates Mamba to Python 3 files"
+version = "0.3.0"
+authors = ["Joël Abrahams <abrahamsjo@gmail.com>"]
+description = "A transpiler which converts Mamba files to Python 3 files"
 edition = "2018"
 license-file = "LICENSE"
 
@@ -17,10 +17,13 @@ appveyor = { repository = "JSAbrahams/mamba", branch = "master", service = "gith
 travis-ci = { repository = "JSAbrahams/mamba", branch = "master" }
 
 [dependencies]
+tempfile = "3.1.0"
 assert_cmd = "0.10"
 python-parser = "0.1.0"
 clap = {version = "2.33", features = ["yaml"]}
-leg = "0.1.3"
 pathdiff = "0.1.0"
 glob = "0.3.0"
 itertools = "0.8.2"
+log = "0.4"
+loggerv = "0.7"
+ansi_term = "0.12.1"

Cargo.toml

@@ -44,7 +44,7 @@ For more extensive examples and explanations check out the [documentation](https
 
 We can write a simple script that computes the factorial of a value given by the user.
 ```mamba
-def factorial(x: Int) => match x
+def factorial(x: Int) -> Int => match x
     0 => 1
     n => n * factorial(n - 1)
 
@@ -321,7 +321,21 @@ In future we might want to add an option to compile down to Python bytecode, but
 
 ### Usage
 ```
-mamba [OPTIONS]
+mamba [FLAGS] [OPTIONS]
+```
+
+### FLAGS
+```
+-d, --debug             Add line numbers to log statements
+-h, --help              Prints help information
+-l, --level             Print log level
+    --no-module-path    Disable the module path in the log statements
+    --no-color          Disable colorized output
+-v                      Set level of verbosity
+                        -    : info, error, warning printed to sterr (Default)
+                        - v  : debug messages are printed
+                        - vv : trace messages are printed
+-V, --version           Prints version information
 ```
 
 ### Options
@@ -330,7 +344,7 @@ mamba [OPTIONS]
                          If file, file taken as input.
                          If directory, recursively search all sub-directories for *.mamba files.
                          If no input given, current directory used as input directory.
--o, --output <OUTPUT>    Output directory to store mamba files.
+-o, --output <OUTPUT>    Output directory to store Python files.
                          Output directory structure reflects input directory structure.
                          If no output given, 'target' directory created in current directory and is used as ouput.
 ```

README.md

@@ -0,0 +1,98 @@
+use crate::check::constrain::constraint::expected::Expected;
+use crate::check::constrain::constraint::iterator::Constraints;
+use crate::check::constrain::constraint::Constraint;
+use crate::check::context::name::DirectName;
+use crate::check::result::{TypeErr, TypeResult};
+use crate::common::position::Position;
+
+/// Constraint Builder.
+///
+/// Allows us to build sets of constraints.
+/// This allows us to constrain different parts of the program which may rely on
+/// the same logic, without interfering with each other. E.g. different
+/// functions within the same class.
+///
+/// The level indicates how deep we are. A level of 0 indicates that we are at
+/// the top-level of a script.
+#[derive(Clone, Debug)]
+pub struct ConstrBuilder {
+    pub level:   usize,
+    finished:    Vec<(Vec<DirectName>, Vec<Constraint>)>,
+    constraints: Vec<(Vec<DirectName>, Vec<Constraint>)>
+}
+
+impl ConstrBuilder {
+    pub fn new() -> ConstrBuilder {
+        ConstrBuilder { level: 0, finished: vec![], constraints: vec![(vec![], vec![])] }
+    }
+
+    pub fn is_top_level(&self) -> bool { self.level == 0 }
+
+    pub fn new_set_in_class(&mut self, inherit_class: bool, class: &DirectName) {
+        self.new_set(false);
+        if self.level > 0 && inherit_class {
+            let mut previous = self.constraints[self.level - 1].0.clone();
+            self.constraints[self.level].0.append(&mut previous);
+        }
+        self.constraints[self.level].0.push(class.clone());
+    }
+
+    /// Remove all constraints with where either parent or child is expected
+    pub fn remove_expected(&mut self, expected: &Expected) {
+        self.constraints[self.level].1 = self.constraints[self.level]
+            .1
+            .clone()
+            .drain_filter(|con| {
+                !con.parent.expect.structurally_eq(&expected.expect)
+                    && !con.child.expect.structurally_eq(&expected.expect)
+            })
+            .collect()
+    }
+
+    pub fn new_set(&mut self, inherit: bool) {
+        self.constraints.push(if inherit {
+            (self.constraints[self.level].0.clone(), self.constraints[self.level].1.clone())
+        } else {
+            (vec![], vec![])
+        });
+        self.level += 1;
+    }
+
+    pub fn exit_set(&mut self, pos: &Position) -> TypeResult<()> {
+        if self.level == 0 {
+            return Err(vec![TypeErr::new(pos, "Cannot exit top-level set")]);
+        }
+
+        self.finished.push(self.constraints.remove(self.level));
+        self.level -= 1;
+        Ok(())
+    }
+
+    pub fn add_with_identifier(
+        &mut self,
+        msg: &str,
+        parent: &Expected,
+        child: &Expected,
+        idens: &[String]
+    ) {
+        let mut constr = Constraint::new(msg, parent, child);
+        constr.ids.append(&mut Vec::from(idens));
+        self.add_constr(&constr);
+    }
+
+    pub fn add(&mut self, msg: &str, parent: &Expected, child: &Expected) {
+        self.add_constr(&Constraint::new(msg, parent, child));
+    }
+
+    pub fn add_constr(&mut self, constraint: &Constraint) {
+        self.constraints[self.level].1.push(constraint.clone())
+    }
+
+    // It is not redundant
+    #[allow(clippy::redundant_clone)]
+    pub fn all_constr(self) -> Vec<Constraints> {
+        let mut finished = self.finished.clone();
+        finished.append(&mut self.constraints.clone());
+        finished.iter().map(Constraints::from).collect()
+    }
+}

src/check/constrain/constraint/builder.rs

@@ -0,0 +1,145 @@
+use std::convert::TryFrom;
+use std::fmt;
+use std::fmt::{Display, Error, Formatter};
+use std::hash::Hash;
+use std::ops::Deref;
+
+use itertools::{EitherOrBoth, Itertools};
+
+use crate::check::constrain::constraint::expected::Expect::*;
+use crate::check::context::clss;
+use crate::check::context::clss::{BOOL_PRIMITIVE, FLOAT_PRIMITIVE, INT_PRIMITIVE, STRING_PRIMITIVE};
+use crate::check::context::name::{DirectName, NameUnion};
+use crate::check::result::{TypeErr, TypeResult};
+use crate::common::delimit::comma_delm;
+use crate::common::position::Position;
+use crate::parse::ast::{Node, AST};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Expected {
+    pub pos:    Position,
+    pub expect: Expect
+}
+
+impl Expected {
+    pub fn new(pos: &Position, expect: &Expect) -> Expected {
+        Expected { pos: pos.clone(), expect: expect.clone() }
+    }
+}
+
+impl TryFrom<&AST> for Expected {
+    type Error = Vec<TypeErr>;
+
+    /// Creates Expected from AST.
+    ///
+    /// If primitive or Constructor, constructs Type.
+    fn try_from(ast: &AST) -> TypeResult<Expected> {
+        let ast = match &ast.node {
+            Node::Block { statements } | Node::Script { statements } =>
+                statements.last().unwrap_or(ast),
+            _ => ast
+        };
+
+        let expect = match &ast.node {
+            Node::Int { .. } | Node::ENum { .. } => Type { name: NameUnion::from(INT_PRIMITIVE) },
+            Node::Real { .. } => Type { name: NameUnion::from(FLOAT_PRIMITIVE) },
+            Node::Bool { .. } => Type { name: NameUnion::from(BOOL_PRIMITIVE) },
+            Node::Str { .. } => Type { name: NameUnion::from(STRING_PRIMITIVE) },
+            Node::Undefined => Nullable,
+            Node::Underscore => ExpressionAny,
+            _ => Expression { ast: ast.clone() }
+        };
+
+        Ok(Expected::new(&ast.pos, &expect))
+    }
+}
+
+impl TryFrom<&Box<AST>> for Expected {
+    type Error = Vec<TypeErr>;
+
+    fn try_from(ast: &Box<AST>) -> TypeResult<Expected> { Expected::try_from(ast.deref()) }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Expect {
+    Nullable,
+    Expression { ast: AST },
+    ExpressionAny,
+    Collection { ty: Box<Expected> },
+    Raises { name: NameUnion },
+    Function { name: DirectName, args: Vec<Expected> },
+    Field { name: String },
+    Access { entity: Box<Expected>, name: Box<Expected> },
+    Type { name: NameUnion }
+}
+
+impl Display for Expected {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { write!(f, "{}", self.expect) }
+}
+
+impl Expected {
+    pub fn is_expr(&self) -> bool {
+        if let Expression { .. } = self.expect {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl Display for Expect {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "{}", match &self {
+            Nullable => String::from("None"),
+            ExpressionAny => String::from("Any"),
+            Expression { ast } => format!("{}", ast.node),
+            Collection { ty } => format!("Collection[{}]", ty.expect),
+            Raises { name: ty } => format!("Raises[{}]", ty),
+            Access { entity, name } => format!("{}.{}", entity.expect, name.expect),
+            Function { name, args } => format!("{}({})", name, comma_delm(args)),
+            Field { name } => name.clone(),
+            Type { name: ty } => format!("{}", ty)
+        })
+    }
+}
+
+impl Expect {
+    pub fn structurally_eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Collection { ty: l }, Collection { ty: r }) => l.expect.structurally_eq(&r.expect),
+            (Field { name: l }, Field { name: r }) => l == r,
+            (Raises { name: l }, Raises { name: r }) | (Type { name: l }, Type { name: r }) =>
+                l == r,
+            (Access { entity: le, name: ln }, Access { entity: re, name: rn }) =>
+                le == re && ln == rn,
+            (Function { name: l, args: la }, Function { name: r, args: ra }) =>
+                l == r
+                    && la.iter().zip_longest(ra.iter()).all(|pair| {
+                        if let EitherOrBoth::Both(left, right) = pair {
+                            left.expect.structurally_eq(&right.expect)
+                        } else {
+                            false
+                        }
+                    }),
+
+            (Expression { ast: l }, Expression { ast: r }) => l.equal_structure(r),
+
+            (ExpressionAny, ExpressionAny) | (Nullable, Nullable) => true,
+
+            (Type { name: ty, .. }, Expression { ast: AST { node: Node::Str { .. }, .. } })
+            | (Expression { ast: AST { node: Node::Str { .. }, .. } }, Type { name: ty, .. })
+                if ty == &NameUnion::from(clss::STRING_PRIMITIVE) =>
+                true,
+            (Type { name: ty, .. }, Expression { ast: AST { node: Node::Real { .. }, .. } })
+            | (Expression { ast: AST { node: Node::Real { .. }, .. } }, Type { name: ty, .. })
+                if ty == &NameUnion::from(clss::FLOAT_PRIMITIVE) =>
+                true,
+            (Type { name: ty, .. }, Expression { ast: AST { node: Node::Int { .. }, .. } })
+            | (Expression { ast: AST { node: Node::Int { .. }, .. } }, Type { name: ty, .. })
+                if ty == &NameUnion::from(clss::INT_PRIMITIVE) =>
+                true,
+
+            _ => false
+        }
+    }
+}

src/check/constrain/constraint/expected.rs

@@ -0,0 +1,65 @@
+use std::collections::VecDeque;
+
+use crate::check::constrain::constraint::expected::Expected;
+use crate::check::constrain::constraint::Constraint;
+use crate::check::context::name::DirectName;
+use crate::check::result::{TypeErr, TypeResult};
+
+#[derive(Clone, Debug)]
+pub struct Constraints {
+    pub in_class: Vec<DirectName>,
+    constraints:  VecDeque<Constraint>
+}
+
+impl From<&(Vec<DirectName>, Vec<Constraint>)> for Constraints {
+    fn from((in_class, constraints): &(Vec<DirectName>, Vec<Constraint>)) -> Self {
+        let constraints = VecDeque::from(constraints.clone());
+        Constraints { in_class: in_class.clone(), constraints }
+    }
+}
+
+impl Constraints {
+    pub fn new(in_class: &[DirectName]) -> Constraints {
+        Constraints { in_class: Vec::from(in_class), constraints: VecDeque::new() }
+    }
+
+    pub fn len(&self) -> usize { self.constraints.len() }
+
+    pub fn pop_constr(&mut self) -> Option<Constraint> { self.constraints.pop_front() }
+
+    /// Push constraint at front so that it will be analysed next.
+    ///
+    /// Only used during unification stage.
+    /// Marks constraint as generated.
+    pub fn push(&mut self, msg: &str, parent: &Expected, child: &Expected) {
+        self.constraints.push_front(Constraint::new(msg, parent, child).as_gen())
+    }
+
+    /// Append in_class and constraints of constraints to self
+    pub fn append(&mut self, constraints: &mut Constraints) {
+        self.in_class.append(&mut constraints.in_class);
+        self.constraints.append(&mut constraints.constraints)
+    }
+
+    pub fn push_constr(&mut self, constr: &Constraint) {
+        self.constraints.push_back(constr.clone())
+    }
+
+    pub fn reinsert(&mut self, constraint: &Constraint) -> TypeResult<()> {
+        if constraint.is_flag {
+            // Can only reinsert constraint once
+            let msg = format!(
+                "Cannot infer type, expected '{}' but was '{}'",
+                &constraint.parent.expect, &constraint.child.expect
+            );
+            return Err(vec![TypeErr::new(&constraint.parent.pos, &msg)]);
+        }
+
+        self.constraints.push_back(constraint.flag());
+        Ok(())
+    }
+}
+
+impl Default for Constraints {
+    fn default() -> Self { Constraints::new(&[]) }
+}