Merge pull request #103 from matter-labs/development

Release v0.1.3

CHANGELOG.md

@@ -1,5 +1,12 @@
 # The Zinc changelog
 
+## Version 0.1.3 (2020-02-17)
+
+### Compiler
+
+- fix the compile error with a comment at the end of a file
+- add an empty statement to allow optional semicolons
+
 ## Version 0.1.2 (2020-02-14)
 
 ### Language

Dockerfile

@@ -1,6 +1,7 @@
 FROM rust:1.41 as builder-linux-musl
-COPY . .
+COPY . zinc-dev/
 
+WORKDIR /zinc-dev/
 RUN apt update -y && apt install -y musl musl-dev musl-tools
 RUN rustup target add x86_64-unknown-linux-musl
 RUN cargo build --verbose --release --target x86_64-unknown-linux-musl

zargo/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zargo"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["hedgar2017 <[email protected]>"]
 edition = "2018"
 description = "The Zinc's circuit manager"

zinc-book/src/05-operators/01-arithmetic.md

@@ -8,11 +8,11 @@ Both operands of a binary operator must always be of the same type, e.g.:
 - `i64` and `i64`
 - `field` and `field`
 
-> The operators `/`, `%`, `>=`, `>`, `<=`, `<` are temporarily forbidden for the
+> The operators `/` and `%` are temporarily forbidden for the
 > type `field`, but will probably become available soon.
 
 > When is comes to the division of negative numbers, Zinc follows the Euclidean
-> division concept. It means that `-45 / 7 == 4`. To get the detailed explanation
+> division concept. It means that `-45 % 7 == 4`. To get the detailed explanation
 > and some examples, see the [article](https://en.wikipedia.org/wiki/Euclidean_division).
 
 #### Addition

zinc-book/src/05-operators/02-comparison.md

@@ -1,5 +1,8 @@
 # Comparison operators
 
+> The operators `>=`, `>`, `<=`, `<` are temporarily forbidden for the
+> type `field`, but will probably become available soon.
+
 #### Equality
 
 `==` is a binary operator.

zinc-book/src/appendix/A-grammar-lexical.md

@@ -6,7 +6,7 @@ These are the Zinc lexical grammar rules in the EWBF notation.
 lexeme = comment | identifier | keyword | literal | symbol | EOF ;
 
 comment = single_line_comment | multi_line_comment ;
-single_line_comment = '//', ( ? ANY ? - '\n' ), '\n' ;
+single_line_comment = '//', ( ? ANY ? - '\n' | EOF ), '\n' | EOF ;
 multi_line_comment = '/*', ( ? ANY ? - '*/' ), '*/' ;
 
 identifier = (

zinc-book/src/appendix/B-grammar-syntax.md

@@ -16,17 +16,22 @@ module_local_statement =
   | mod_statement
   | use_statement
   | impl_statement
+  | empty_statement
+;
 
 function_local_statement =
     let_statement
   | const_statement
   | loop_statement
+  | empty_statement
   | expression
+;
 
 implementation_local_statement =
     const_statement
   | fn_statement
-';' ;
+  | empty_statement
+;
 
 let_statement = 'let', [ 'mut' ], identifier, [ ':', type ], '=', expression ;
 loop_statement = 'for', identifier, 'in', expression, [ 'while', expression ], block_expression ;
@@ -37,6 +42,7 @@ fn_statement = 'fn', identifier, '(', field_list, ')', [ '->', type ], block_exp
 mod_statement = 'mod', identifier ;
 use_statement = 'use', path_expression ;
 impl_statement = 'impl', identifier, '{', { implementation_local_statement }, '}' ;
+empty_statement = ';' ;
 
 (* Expressions *)
 expression = operand_assignment, [ '=', operand_assignment ] ;

zinc-bytecode/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zinc-bytecode"
-version = "0.1.2"
+version = "0.1.3"
 authors = [
     "Alexander Movchan <[email protected]>",
     "hedgar2017 <[email protected]>",

zinc-compiler/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "zinc-compiler"
-version = "0.1.2"
+version = "0.1.3"
 authors = [
     "hedgar2017 <[email protected]>",
     "Alexander Movchan <[email protected]>",

zinc-compiler/src/lexical/stream/comment.rs

@@ -28,67 +28,72 @@ pub fn parse(input: &str) -> Result<(usize, usize, usize, Comment), Error> {
     let mut lines = 0;
     let mut column = 1;
 
-    while let Some(character) = input.chars().nth(size) {
+    loop {
+        let character = input.chars().nth(size);
         match state {
             State::Start => match character {
-                '/' => {
+                Some('/') => {
                     size += 1;
                     column += 1;
                     state = State::Slash;
                 }
-                _ => return Err(Error::NotAComment),
+                Some(_) => return Err(Error::NotAComment),
+                None => break,
             },
             State::Slash => match character {
-                '/' => {
+                Some('/') => {
                     size += 1;
                     column += 1;
                     state = State::SingleLine;
                 }
-                '*' => {
+                Some('*') => {
                     size += 1;
                     column += 1;
                     state = State::MultiLine;
                 }
-                _ => return Err(Error::NotAComment),
+                Some(_) => return Err(Error::NotAComment),
+                None => break,
             },
             State::SingleLine => match character {
-                '\n' => {
+                Some('\n') | None => {
                     let comment = Comment::new(input[2..size].to_owned());
                     return Ok((size, lines, column, comment));
                 }
-                _ => {
+                Some(_) => {
                     size += 1;
                     column += 1;
                 }
             },
             State::MultiLine => match character {
-                '*' => {
+                Some('*') => {
                     size += 1;
                     column += 1;
                     state = State::MultiLineStar;
                 }
-                '\n' => {
+                Some('\n') => {
                     size += 1;
                     column = 1;
                     lines += 1;
                 }
-                _ => {
+                Some(_) => {
                     size += 1;
                     column += 1;
                 }
+                None => break,
             },
             State::MultiLineStar => match character {
-                '/' => {
+                Some('/') => {
                     size += 1;
                     column += 1;
                     let comment = Comment::new(input[2..size - 2].to_owned());
                     return Ok((size, lines, column, comment));
                 }
-                _ => {
+                Some(_) => {
                     size += 1;
                     column += 1;
                     state = State::MultiLine;
                 }
+                None => break,
             },
         }
     }
@@ -103,7 +108,7 @@ mod tests {
     use crate::lexical::token::lexeme::comment::Comment;
 
     #[test]
-    fn ok_single_line() {
+    fn ok_single_line_with_break() {
         let input = "//mega ultra comment text\n";
         let expected = Ok((
             25,
@@ -115,6 +120,19 @@ mod tests {
         assert_eq!(result, expected);
     }
 
+    #[test]
+    fn ok_single_line_with_eof() {
+        let input = "//mega ultra comment text";
+        let expected = Ok((
+            25,
+            0,
+            26,
+            Comment::new("mega ultra comment text".to_owned()),
+        ));
+        let result = parse(input);
+        assert_eq!(result, expected);
+    }
+
     #[test]
     fn ok_multi_line() {
         let input = r#"/*
@@ -130,14 +148,6 @@ mod tests {
         assert_eq!(result, expected);
     }
 
-    #[test]
-    fn err_single_line_unexpected_end() {
-        let input = "//mega ultra comment text";
-        let expected = Err(Error::UnexpectedEnd);
-        let result = parse(input);
-        assert_eq!(result, expected);
-    }
-
     #[test]
     fn err_multi_line_unexpected_end() {
         let input = r#"/* This is the mega ultra test application!"#;

zinc-compiler/src/lib.rs

@@ -3,6 +3,7 @@
 //!
 
 #![allow(clippy::implicit_hasher)]
+#![allow(clippy::large_enum_variant)]
 
 mod error;
 mod lexical;

zinc-compiler/src/main.rs

@@ -58,7 +58,7 @@ struct Arguments {
 enum Error {
     #[fail(display = "source file: {}", _0)]
     SourceFile(FileError),
-    #[fail(display = "compiler: {}:{}", _0, _1)]
+    #[fail(display = "{}:{}", _0, _1)]
     Compiler(String, zinc_compiler::Error),
     #[fail(display = "witness template output: {}", _0)]
     WitnessTemplateOutput(OutputError),

zinc-compiler/src/semantic/analyzer/statement.rs

@@ -73,47 +73,45 @@ impl Analyzer {
 
     pub fn module_local_statement(&mut self, statement: ModuleLocalStatement) -> Result<(), Error> {
         match statement {
-            ModuleLocalStatement::Const(statement) => self.const_statement(statement)?,
-            ModuleLocalStatement::Static(statement) => self.static_statement(statement)?,
-            ModuleLocalStatement::Type(statement) => self.type_statement(statement)?,
-            ModuleLocalStatement::Struct(statement) => self.struct_statement(statement)?,
-            ModuleLocalStatement::Enum(statement) => self.enum_statement(statement)?,
-            ModuleLocalStatement::Fn(statement) => self.fn_statement(statement)?,
-            ModuleLocalStatement::Mod(statement) => self.mod_statement(statement)?,
-            ModuleLocalStatement::Use(statement) => self.use_statement(statement)?,
-            ModuleLocalStatement::Impl(statement) => self.impl_statement(statement)?,
+            ModuleLocalStatement::Const(statement) => self.const_statement(statement),
+            ModuleLocalStatement::Static(statement) => self.static_statement(statement),
+            ModuleLocalStatement::Type(statement) => self.type_statement(statement),
+            ModuleLocalStatement::Struct(statement) => self.struct_statement(statement),
+            ModuleLocalStatement::Enum(statement) => self.enum_statement(statement),
+            ModuleLocalStatement::Fn(statement) => self.fn_statement(statement),
+            ModuleLocalStatement::Mod(statement) => self.mod_statement(statement),
+            ModuleLocalStatement::Use(statement) => self.use_statement(statement),
+            ModuleLocalStatement::Impl(statement) => self.impl_statement(statement),
+            ModuleLocalStatement::Empty => Ok(()),
         }
-
-        Ok(())
     }
 
     pub fn function_local_statement(
         &mut self,
         statement: FunctionLocalStatement,
     ) -> Result<(), Error> {
         match statement {
-            FunctionLocalStatement::Let(statement) => self.let_statement(statement)?,
-            FunctionLocalStatement::Const(statement) => self.const_statement(statement)?,
-            FunctionLocalStatement::Loop(statement) => self.loop_statement(statement)?,
+            FunctionLocalStatement::Let(statement) => self.let_statement(statement),
+            FunctionLocalStatement::Const(statement) => self.const_statement(statement),
+            FunctionLocalStatement::Loop(statement) => self.loop_statement(statement),
             FunctionLocalStatement::Expression(expression) => {
                 ExpressionAnalyzer::new(self.scope(), self.bytecode.clone())
                     .expression(expression, TranslationHint::ValueExpression)?;
+                Ok(())
             }
+            FunctionLocalStatement::Empty => Ok(()),
         }
-
-        Ok(())
     }
 
     pub fn implementation_local_statement(
         &mut self,
         statement: ImplementationLocalStatement,
     ) -> Result<(), Error> {
         match statement {
-            ImplementationLocalStatement::Const(statement) => self.const_statement(statement)?,
-            ImplementationLocalStatement::Fn(statement) => self.fn_statement(statement)?,
+            ImplementationLocalStatement::Const(statement) => self.const_statement(statement),
+            ImplementationLocalStatement::Fn(statement) => self.fn_statement(statement),
+            ImplementationLocalStatement::Empty => Ok(()),
         }
-
-        Ok(())
     }
 
     fn const_statement(&mut self, statement: ConstStatement) -> Result<(), Error> {

zinc-compiler/src/syntax/parser/statement/local_function.rs

@@ -61,6 +61,10 @@ impl Parser {
                     LoopStatementParser::default().parse(stream.clone(), Some(token))?;
                 FunctionLocalStatement::Loop(statement)
             }
+            Token {
+                lexeme: Lexeme::Symbol(Symbol::Semicolon),
+                ..
+            } => return Ok((FunctionLocalStatement::Empty, None, false)),
             token => {
                 let (expression, next) =
                     ExpressionParser::default().parse(stream.clone(), Some(token))?;

zinc-compiler/src/syntax/parser/statement/local_implementation.rs

@@ -8,6 +8,7 @@ use std::rc::Rc;
 use crate::error::Error;
 use crate::lexical::Keyword;
 use crate::lexical::Lexeme;
+use crate::lexical::Symbol;
 use crate::lexical::Token;
 use crate::lexical::TokenStream;
 use crate::syntax::ConstStatementParser;
@@ -41,6 +42,10 @@ impl Parser {
             } => FnStatementParser::default()
                 .parse(stream, Some(token))
                 .map(|(statement, next)| (ImplementationLocalStatement::Fn(statement), next)),
+            Token {
+                lexeme: Lexeme::Symbol(Symbol::Semicolon),
+                ..
+            } => Ok((ImplementationLocalStatement::Empty, None)),
             Token { lexeme, location } => Err(Error::Syntax(SyntaxError::Expected(
                 location,
                 vec!["const", "fn"],