Migrates statements

ast/src/ast.rs

@@ -2,12 +2,11 @@
 use crate::{
     imports::Import,
     operations::{
-        AssignOperation,
         BinaryOperation,
         NotOperation,
     },
     statements::{
-        ForStatement
+        Statement
     },
     types::{
         ArrayType,
@@ -644,197 +643,6 @@ impl<'ast> FromPest<'ast> for Expression<'ast> {
     }
 }
 
-// Statements
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_return))]
-pub struct ReturnStatement<'ast> {
-    pub expressions: Vec<Expression<'ast>>,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::conditional_nested_or_end))]
-pub enum ConditionalNestedOrEnd<'ast> {
-    Nested(Box<ConditionalStatement<'ast>>),
-    End(Vec<Statement<'ast>>),
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_conditional))]
-pub struct ConditionalStatement<'ast> {
-    pub condition: Expression<'ast>,
-    pub statements: Vec<Statement<'ast>>,
-    pub next: Option<ConditionalNestedOrEnd<'ast>>,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_multiple_assignment))]
-pub struct MultipleAssignmentStatement<'ast> {
-    pub variables: Vec<Variable<'ast>>,
-    pub function_name: Identifier<'ast>,
-    pub arguments: Vec<Expression<'ast>>,
-    pub line_end: LineEnd,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_definition))]
-pub struct DefinitionStatement<'ast> {
-    pub variable: Variable<'ast>,
-    pub expression: Expression<'ast>,
-    pub line_end: LineEnd,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_assign))]
-pub struct AssignStatement<'ast> {
-    pub assignee: Assignee<'ast>,
-    pub assign: AssignOperation,
-    pub expression: Expression<'ast>,
-    pub line_end: LineEnd,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::assert_eq))]
-pub struct AssertEq<'ast> {
-    pub left: Expression<'ast>,
-    pub right: Expression<'ast>,
-    pub line_end: LineEnd,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_assert))]
-pub enum AssertStatement<'ast> {
-    AssertEq(AssertEq<'ast>),
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement_expression))]
-pub struct ExpressionStatement<'ast> {
-    pub expression: Expression<'ast>,
-    pub line_end: LineEnd,
-    #[pest_ast(outer())]
-    pub span: Span<'ast>,
-}
-
-#[derive(Clone, Debug, FromPest, PartialEq)]
-#[pest_ast(rule(Rule::statement))]
-pub enum Statement<'ast> {
-    Return(ReturnStatement<'ast>),
-    Definition(DefinitionStatement<'ast>),
-    Assign(AssignStatement<'ast>),
-    MultipleAssignment(MultipleAssignmentStatement<'ast>),
-    Conditional(ConditionalStatement<'ast>),
-    Iteration(ForStatement<'ast>),
-    Assert(AssertStatement<'ast>),
-    Expression(ExpressionStatement<'ast>),
-}
-
-impl<'ast> fmt::Display for ReturnStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, expression) in self.expressions.iter().enumerate() {
-            write!(f, "{}", expression)?;
-            if i < self.expressions.len() - 1 {
-                write!(f, ", ")?;
-            }
-        }
-        write!(f, "")
-    }
-}
-
-impl<'ast> fmt::Display for ConditionalNestedOrEnd<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ConditionalNestedOrEnd::Nested(ref nested) => write!(f, "else {}", nested),
-            ConditionalNestedOrEnd::End(ref statements) => {
-                write!(f, "else {{\n \t{:#?}\n }}", statements)
-            }
-        }
-    }
-}
-
-impl<'ast> fmt::Display for ConditionalStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "if ({}) {{\n", self.condition)?;
-        write!(f, "\t{:#?}\n", self.statements)?;
-        self.next
-            .as_ref()
-            .map(|n_or_e| write!(f, "}} {}", n_or_e))
-            .unwrap_or(write!(f, "}}"))
-    }
-}
-
-impl<'ast> fmt::Display for ForStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "for {} in {}..{} {{ {:#?} }}",
-            self.index, self.start, self.stop, self.statements
-        )
-    }
-}
-
-impl<'ast> fmt::Display for MultipleAssignmentStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, id) in self.variables.iter().enumerate() {
-            write!(f, "{}", id)?;
-            if i < self.variables.len() - 1 {
-                write!(f, ", ")?;
-            }
-        }
-        write!(f, " = {}", self.function_name)
-    }
-}
-
-impl<'ast> fmt::Display for DefinitionStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "let {} = {};", self.variable, self.expression)
-    }
-}
-
-impl<'ast> fmt::Display for AssignStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} = {};", self.assignee, self.expression)
-    }
-}
-
-impl<'ast> fmt::Display for AssertStatement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            AssertStatement::AssertEq(ref assert) => {
-                write!(f, "assert_eq({}, {});", assert.left, assert.right)
-            }
-        }
-    }
-}
-
-impl<'ast> fmt::Display for Statement<'ast> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Statement::Return(ref statement) => write!(f, "{}", statement),
-            Statement::Definition(ref statement) => write!(f, "{}", statement),
-            Statement::Assign(ref statement) => write!(f, "{}", statement),
-            Statement::MultipleAssignment(ref statement) => write!(f, "{}", statement),
-            Statement::Conditional(ref statement) => write!(f, "{}", statement),
-            Statement::Iteration(ref statement) => write!(f, "{}", statement),
-            Statement::Assert(ref statement) => write!(f, "{}", statement),
-            Statement::Expression(ref statement) => write!(f, "{}", statement.expression),
-        }
-    }
-}
-
 // Functions
 
 #[derive(Clone, Debug, FromPest, PartialEq)]

ast/src/leo.pest

@@ -201,22 +201,7 @@ conditional_nested_or_end = { statement_conditional | "{" ~ NEWLINE* ~ statement
 
 /// Statements
 
-statement_return = { "return" ~ expression_tuple }
-statement_definition = { "let" ~ variable ~ "=" ~ expression ~ LINE_END}
-statement_assign = { assignee ~ operation_assign ~ expression ~ LINE_END}
-statement_multiple_assignment = { "let" ~ "(" ~ variable_tuple ~ ")" ~ "=" ~  identifier ~ "(" ~ expression_tuple ~ ")" ~ LINE_END}
-statement_conditional = {"if" ~ (expression | "(" ~ expression ~ ")") ~ "{" ~ NEWLINE* ~ statement+ ~ "}" ~ ("else" ~ conditional_nested_or_end)?}
-
-// Declared in types/for_statement.rs
-statement_for = { "for" ~ identifier ~ "in" ~ expression ~ ".." ~ expression ~ "{" ~ NEWLINE* ~ statement+ ~ "}"}
-
-
-statement_assert = {
-    assert_eq
-//     | assert_true |
-}
-statement_expression = { expression ~ LINE_END }
-
+// Declared in statements/statement.rs
 statement = {
     (statement_return
     | statement_conditional
@@ -230,6 +215,30 @@ statement = {
     ) ~ NEWLINE*
 }
 
+// Declared in statements/assert_statement.rs
+statement_assert = { assert_eq }
+
+// Declared in statements/assign_statement.rs
+statement_assign = { assignee ~ operation_assign ~ expression ~ LINE_END }
+
+// Declared in statements/conditional_statement.rs
+statement_conditional = {"if" ~ (expression | "(" ~ expression ~ ")") ~ "{" ~ NEWLINE* ~ statement+ ~ "}" ~ ("else" ~ conditional_nested_or_end)?}
+
+// Declared in statements/definition_statement.rs
+statement_definition = { "let" ~ variable ~ "=" ~ expression ~ LINE_END}
+
+// Declared in statements/expression_statement.rs
+statement_expression = { expression ~ LINE_END }
+
+// Declared in statements/for_statement.rs
+statement_for = { "for" ~ identifier ~ "in" ~ expression ~ ".." ~ expression ~ "{" ~ NEWLINE* ~ statement+ ~ "}"}
+
+// Declared in statements/multiple_assignment_statement.rs
+statement_multiple_assignment = { "let" ~ "(" ~ variable_tuple ~ ")" ~ "=" ~  identifier ~ "(" ~ expression_tuple ~ ")" ~ LINE_END}
+
+// Declared in statements/return_statement.rs
+statement_return = { "return" ~ expression_tuple }
+
 /// Functions
 
 input_model = {mutable? ~ identifier ~ ":" ~ visibility? ~ _type}

ast/src/statements/assert_statement.rs

@@ -0,0 +1,31 @@
+use crate::ast::{Expression, Rule, LineEnd};
+
+use pest::Span;
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_assert))]
+pub enum AssertStatement<'ast> {
+    AssertEq(AssertEq<'ast>),
+}
+
+impl<'ast> fmt::Display for AssertStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            AssertStatement::AssertEq(ref assert) => {
+                write!(f, "assert_eq({}, {});", assert.left, assert.right)
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::assert_eq))]
+pub struct AssertEq<'ast> {
+    pub left: Expression<'ast>,
+    pub right: Expression<'ast>,
+    pub line_end: LineEnd,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}

ast/src/statements/assign_statement.rs

@@ -0,0 +1,22 @@
+use crate::{ast::{Expression, Rule, LineEnd, Assignee}, operations::AssignOperation};
+
+use pest::Span;
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_assign))]
+pub struct AssignStatement<'ast> {
+    pub assignee: Assignee<'ast>,
+    pub assign: AssignOperation,
+    pub expression: Expression<'ast>,
+    pub line_end: LineEnd,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}
+
+impl<'ast> fmt::Display for AssignStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} = {};", self.assignee, self.expression)
+    }
+}

ast/src/statements/conditional_nested_or_end_statement.rs

@@ -0,0 +1,22 @@
+use crate::{ast::Rule, statements::{ConditionalStatement, Statement}};
+
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::conditional_nested_or_end))]
+pub enum ConditionalNestedOrEndStatement<'ast> {
+    Nested(Box<ConditionalStatement<'ast>>),
+    End(Vec<Statement<'ast>>),
+}
+
+impl<'ast> fmt::Display for ConditionalNestedOrEndStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ConditionalNestedOrEndStatement::Nested(ref nested) => write!(f, "else {}", nested),
+            ConditionalNestedOrEndStatement::End(ref statements) => {
+                write!(f, "else {{\n \t{:#?}\n }}", statements)
+            }
+        }
+    }
+}

ast/src/statements/conditional_statement.rs

@@ -0,0 +1,26 @@
+use crate::{ast::{Expression, Rule}, statements::{ConditionalNestedOrEndStatement, Statement}};
+
+use pest::Span;
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_conditional))]
+pub struct ConditionalStatement<'ast> {
+    pub condition: Expression<'ast>,
+    pub statements: Vec<Statement<'ast>>,
+    pub next: Option<ConditionalNestedOrEndStatement<'ast>>,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}
+
+impl<'ast> fmt::Display for ConditionalStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "if ({}) {{\n", self.condition)?;
+        write!(f, "\t{:#?}\n", self.statements)?;
+        self.next
+            .as_ref()
+            .map(|n_or_e| write!(f, "}} {}", n_or_e))
+            .unwrap_or(write!(f, "}}"))
+    }
+}

ast/src/statements/definition_statement.rs

@@ -0,0 +1,21 @@
+use crate::ast::{Expression, Rule, LineEnd, Variable};
+
+use pest::Span;
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_definition))]
+pub struct DefinitionStatement<'ast> {
+    pub variable: Variable<'ast>,
+    pub expression: Expression<'ast>,
+    pub line_end: LineEnd,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}
+
+impl<'ast> fmt::Display for DefinitionStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "let {} = {};", self.variable, self.expression)
+    }
+}

ast/src/statements/expression_statement.rs

@@ -0,0 +1,13 @@
+use crate::ast::{Expression, Rule, LineEnd};
+
+use pest::Span;
+use pest_ast::FromPest;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_expression))]
+pub struct ExpressionStatement<'ast> {
+    pub expression: Expression<'ast>,
+    pub line_end: LineEnd,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}

ast/src/statements/for_statement.rs

@@ -1,7 +1,8 @@
-use crate::{ast::{Expression, Statement, Rule}, types::Identifier};
+use crate::{ast::{Expression, Rule}, statements::Statement, types::Identifier};
 
 use pest::Span;
 use pest_ast::FromPest;
+use std::fmt;
 
 #[derive(Clone, Debug, FromPest, PartialEq)]
 #[pest_ast(rule(Rule::statement_for))]
@@ -13,3 +14,13 @@ pub struct ForStatement<'ast> {
     #[pest_ast(outer())]
     pub span: Span<'ast>,
 }
+
+impl<'ast> fmt::Display for ForStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "for {} in {}..{} {{ {:#?} }}",
+            self.index, self.start, self.stop, self.statements
+        )
+    }
+}

ast/src/statements/mod.rs

@@ -1,2 +1,29 @@
+pub mod assert_statement;
+pub use assert_statement::*;
+
+pub mod assign_statement;
+pub use assign_statement::*;
+
+pub mod conditional_statement;
+pub use conditional_statement::*;
+
+pub mod conditional_nested_or_end_statement;
+pub use conditional_nested_or_end_statement::*;
+
+pub mod definition_statement;
+pub use definition_statement::*;
+
+pub mod expression_statement;
+pub use expression_statement::*;
+
 pub mod for_statement;
 pub use for_statement::*;
+
+pub mod multiple_assignment_statement;
+pub use multiple_assignment_statement::*;
+
+pub mod return_statement;
+pub use return_statement::*;
+
+pub mod statement;
+pub use statement::*;

ast/src/statements/multiple_assignment_statement.rs

@@ -0,0 +1,28 @@
+use crate::{ast::{Expression, Rule, LineEnd, Variable}, types::Identifier};
+
+use pest::Span;
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_multiple_assignment))]
+pub struct MultipleAssignmentStatement<'ast> {
+    pub variables: Vec<Variable<'ast>>,
+    pub function_name: Identifier<'ast>,
+    pub arguments: Vec<Expression<'ast>>,
+    pub line_end: LineEnd,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}
+
+impl<'ast> fmt::Display for MultipleAssignmentStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for (i, id) in self.variables.iter().enumerate() {
+            write!(f, "{}", id)?;
+            if i < self.variables.len() - 1 {
+                write!(f, ", ")?;
+            }
+        }
+        write!(f, " = {}", self.function_name)
+    }
+}

ast/src/statements/return_statement.rs

@@ -0,0 +1,25 @@
+use crate::ast::{Expression, Rule};
+
+use pest::Span;
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement_return))]
+pub struct ReturnStatement<'ast> {
+    pub expressions: Vec<Expression<'ast>>,
+    #[pest_ast(outer())]
+    pub span: Span<'ast>,
+}
+
+impl<'ast> fmt::Display for ReturnStatement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for (i, expression) in self.expressions.iter().enumerate() {
+            write!(f, "{}", expression)?;
+            if i < self.expressions.len() - 1 {
+                write!(f, ", ")?;
+            }
+        }
+        write!(f, "")
+    }
+}

ast/src/statements/statement.rs

@@ -0,0 +1,32 @@
+use crate::{ast::Rule, statements::*};
+
+use pest_ast::FromPest;
+use std::fmt;
+
+#[derive(Clone, Debug, FromPest, PartialEq)]
+#[pest_ast(rule(Rule::statement))]
+pub enum Statement<'ast> {
+    Return(ReturnStatement<'ast>),
+    Definition(DefinitionStatement<'ast>),
+    Assign(AssignStatement<'ast>),
+    MultipleAssignment(MultipleAssignmentStatement<'ast>),
+    Conditional(ConditionalStatement<'ast>),
+    Iteration(ForStatement<'ast>),
+    Assert(AssertStatement<'ast>),
+    Expression(ExpressionStatement<'ast>),
+}
+
+impl<'ast> fmt::Display for Statement<'ast> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Statement::Return(ref statement) => write!(f, "{}", statement),
+            Statement::Definition(ref statement) => write!(f, "{}", statement),
+            Statement::Assign(ref statement) => write!(f, "{}", statement),
+            Statement::MultipleAssignment(ref statement) => write!(f, "{}", statement),
+            Statement::Conditional(ref statement) => write!(f, "{}", statement),
+            Statement::Iteration(ref statement) => write!(f, "{}", statement),
+            Statement::Assert(ref statement) => write!(f, "{}", statement),
+            Statement::Expression(ref statement) => write!(f, "{}", statement.expression),
+        }
+    }
+}

compiler/src/types_from.rs

@@ -12,7 +12,16 @@ use leo_ast::{
         BinaryOperation,
     },
     statements::{
+        AssertStatement,
+        AssignStatement,
+        ConditionalStatement,
+        ConditionalNestedOrEndStatement,
+        DefinitionStatement,
+        ExpressionStatement,
         ForStatement,
+        MultipleAssignmentStatement,
+        ReturnStatement,
+        Statement,
     },
     types::{
         ArrayType,
@@ -452,8 +461,8 @@ impl<'ast> From<ast::Assignee<'ast>> for types::Assignee {
 
 /// pest ast -> types::Statement
 
-impl<'ast> From<ast::ReturnStatement<'ast>> for types::Statement {
-    fn from(statement: ast::ReturnStatement<'ast>) -> Self {
+impl<'ast> From<ReturnStatement<'ast>> for types::Statement {
+    fn from(statement: ReturnStatement<'ast>) -> Self {
         types::Statement::Return(
             statement
                 .expressions
@@ -464,8 +473,8 @@ impl<'ast> From<ast::ReturnStatement<'ast>> for types::Statement {
     }
 }
 
-impl<'ast> From<ast::DefinitionStatement<'ast>> for types::Statement {
-    fn from(statement: ast::DefinitionStatement<'ast>) -> Self {
+impl<'ast> From<DefinitionStatement<'ast>> for types::Statement {
+    fn from(statement: DefinitionStatement<'ast>) -> Self {
         types::Statement::Definition(
             types::Variable::from(statement.variable),
             types::Expression::from(statement.expression),
@@ -473,8 +482,8 @@ impl<'ast> From<ast::DefinitionStatement<'ast>> for types::Statement {
     }
 }
 
-impl<'ast> From<ast::AssignStatement<'ast>> for types::Statement {
-    fn from(statement: ast::AssignStatement<'ast>) -> Self {
+impl<'ast> From<AssignStatement<'ast>> for types::Statement {
+    fn from(statement: AssignStatement<'ast>) -> Self {
         match statement.assign {
             AssignOperation::Assign(ref _assign) => types::Statement::Assign(
                 types::Assignee::from(statement.assignee),
@@ -529,8 +538,8 @@ impl<'ast> From<ast::AssignStatement<'ast>> for types::Statement {
     }
 }
 
-impl<'ast> From<ast::MultipleAssignmentStatement<'ast>> for types::Statement {
-    fn from(statement: ast::MultipleAssignmentStatement<'ast>) -> Self {
+impl<'ast> From<MultipleAssignmentStatement<'ast>> for types::Statement {
+    fn from(statement: MultipleAssignmentStatement<'ast>) -> Self {
         let variables = statement
             .variables
             .into_iter()
@@ -551,13 +560,13 @@ impl<'ast> From<ast::MultipleAssignmentStatement<'ast>> for types::Statement {
     }
 }
 
-impl<'ast> From<ast::ConditionalNestedOrEnd<'ast>> for types::ConditionalNestedOrEnd {
-    fn from(statement: ast::ConditionalNestedOrEnd<'ast>) -> Self {
+impl<'ast> From<ConditionalNestedOrEndStatement<'ast>> for types::ConditionalNestedOrEnd {
+    fn from(statement: ConditionalNestedOrEndStatement<'ast>) -> Self {
         match statement {
-            ast::ConditionalNestedOrEnd::Nested(nested) => types::ConditionalNestedOrEnd::Nested(
+            ConditionalNestedOrEndStatement::Nested(nested) => types::ConditionalNestedOrEnd::Nested(
                 Box::new(types::ConditionalStatement::from(*nested)),
             ),
-            ast::ConditionalNestedOrEnd::End(statements) => types::ConditionalNestedOrEnd::End(
+            ConditionalNestedOrEndStatement::End(statements) => types::ConditionalNestedOrEnd::End(
                 statements
                     .into_iter()
                     .map(|statement| types::Statement::from(statement))
@@ -567,8 +576,8 @@ impl<'ast> From<ast::ConditionalNestedOrEnd<'ast>> for types::ConditionalNestedO
     }
 }
 
-impl<'ast> From<ast::ConditionalStatement<'ast>> for types::ConditionalStatement {
-    fn from(statement: ast::ConditionalStatement<'ast>) -> Self {
+impl<'ast> From<ConditionalStatement<'ast>> for types::ConditionalStatement {
+    fn from(statement: ConditionalStatement<'ast>) -> Self {
         types::ConditionalStatement {
             condition: types::Expression::from(statement.condition),
             statements: statement
@@ -610,10 +619,10 @@ impl<'ast> From<ForStatement<'ast>> for types::Statement {
     }
 }
 
-impl<'ast> From<ast::AssertStatement<'ast>> for types::Statement {
-    fn from(statement: ast::AssertStatement<'ast>) -> Self {
+impl<'ast> From<AssertStatement<'ast>> for types::Statement {
+    fn from(statement: AssertStatement<'ast>) -> Self {
         match statement {
-            ast::AssertStatement::AssertEq(assert_eq) => types::Statement::AssertEq(
+            AssertStatement::AssertEq(assert_eq) => types::Statement::AssertEq(
                 types::Expression::from(assert_eq.left),
                 types::Expression::from(assert_eq.right),
             ),
@@ -621,25 +630,25 @@ impl<'ast> From<ast::AssertStatement<'ast>> for types::Statement {
     }
 }
 
-impl<'ast> From<ast::ExpressionStatement<'ast>> for types::Statement {
-    fn from(statement: ast::ExpressionStatement<'ast>) -> Self {
+impl<'ast> From<ExpressionStatement<'ast>> for types::Statement {
+    fn from(statement: ExpressionStatement<'ast>) -> Self {
         types::Statement::Expression(types::Expression::from(statement.expression))
     }
 }
 
-impl<'ast> From<ast::Statement<'ast>> for types::Statement {
-    fn from(statement: ast::Statement<'ast>) -> Self {
+impl<'ast> From<Statement<'ast>> for types::Statement {
+    fn from(statement: Statement<'ast>) -> Self {
         match statement {
-            ast::Statement::Return(statement) => types::Statement::from(statement),
-            ast::Statement::Definition(statement) => types::Statement::from(statement),
-            ast::Statement::Assign(statement) => types::Statement::from(statement),
-            ast::Statement::MultipleAssignment(statement) => types::Statement::from(statement),
-            ast::Statement::Conditional(statement) => {
+            Statement::Return(statement) => types::Statement::from(statement),
+            Statement::Definition(statement) => types::Statement::from(statement),
+            Statement::Assign(statement) => types::Statement::from(statement),
+            Statement::MultipleAssignment(statement) => types::Statement::from(statement),
+            Statement::Conditional(statement) => {
                 types::Statement::Conditional(types::ConditionalStatement::from(statement))
             }
-            ast::Statement::Iteration(statement) => types::Statement::from(statement),
-            ast::Statement::Assert(statement) => types::Statement::from(statement),
-            ast::Statement::Expression(statement) => types::Statement::from(statement),
+            Statement::Iteration(statement) => types::Statement::from(statement),
+            Statement::Assert(statement) => types::Statement::from(statement),
+            Statement::Expression(statement) => types::Statement::from(statement),
         }
     }
 }