Initial commit for implementing code blocks.

Author: gdotdesign

spec/parsers/function_spec.cr

@@ -9,14 +9,15 @@ describe "Function Definition" do
 
   expect_error "fun", Mint::Parser::FunctionExpectedName
   expect_error "fun ", Mint::Parser::FunctionExpectedName
-  expect_error "fun a", Mint::Parser::FunctionExpectedOpeningBracket
-  expect_error "fun a ", Mint::Parser::FunctionExpectedOpeningBracket
+  expect_error "fun a", Mint::SyntaxError
+  expect_error "fun a ", Mint::SyntaxError
   expect_error "fun a (", Mint::Parser::FunctionExpectedClosingParentheses
   expect_error "fun a ( ", Mint::Parser::FunctionExpectedClosingParentheses
-  expect_error "fun a ()", Mint::Parser::FunctionExpectedOpeningBracket
-  expect_error "fun a () ", Mint::Parser::FunctionExpectedOpeningBracket
+  expect_error "fun a ()", Mint::SyntaxError
+  expect_error "fun a () ", Mint::SyntaxError
   expect_error "fun a () :", Mint::Parser::FunctionExpectedTypeOrVariable
   expect_error "fun a () : ", Mint::Parser::FunctionExpectedTypeOrVariable
+  expect_error "fun a () { x", Mint::SyntaxError
 
   expect_ok "fun a { true } "
   expect_ok "fun a : T { true } "

src/ast/function.cr

@@ -1,5 +1,17 @@
 module Mint
   class Ast
+    class Block < Node
+      getter statements, expression, tail_comments
+
+      def initialize(@tail_comments : Array(Comment),
+                     @statements : Array(Node),
+                     @expression : Expression,
+                     @input : Data,
+                     @from : Int32,
+                     @to : Int32)
+      end
+    end
+
     class Function < Node
       getter name, where, arguments, body, type
       getter comment, head_comments, tail_comments

src/ast/statement.cr

@@ -5,6 +5,7 @@ module Mint
         Try
         Sequence
         Parallel
+        None
       end
 
       getter target, expression, parent

src/compilers/function.cr

@@ -8,6 +8,10 @@ module Mint
       end
     end
 
+    def _compile(node : Ast::Block) : String
+      compile node.expression
+    end
+
     def _compile(node : Ast::Function, contents = "") : String
       name =
         js.variable_of(node)

src/formatters/function.cr

@@ -1,5 +1,9 @@
 module Mint
   class Formatter
+    def format(node : Ast::Block) : String
+      list node.statements + [node.expression] + node.tail_comments
+    end
+
     def format(node : Ast::Function) : String
       name =
         format node.name

src/parsers/block.cr

@@ -21,8 +21,8 @@ module Mint
       whitespace
 
       result = yield
-
       whitespace
+
       char '}', closing_bracket
       result
     end

src/parsers/function.cr

@@ -7,6 +7,35 @@ module Mint
     syntax_error FunctionExpectedExpression
     syntax_error FunctionExpectedName
 
+    def code_block : Ast::Block?
+      start do |start_position|
+        char '{', SyntaxError
+        whitespace
+
+        statements =
+          many { comment || statement(:none, require_name: true) }
+
+        whitespace
+
+        expression =
+          expression! SyntaxError
+
+        whitespace
+        tail_comments = many { comment }
+
+        whitespace
+        char '}', SyntaxError
+
+        self << Ast::Block.new(
+          tail_comments: tail_comments,
+          statements: statements,
+          expression: expression,
+          from: start_position,
+          to: position,
+          input: data)
+      end
+    end
+
     def function : Ast::Function?
       start do |start_position|
         comment = self.comment
@@ -41,21 +70,24 @@ module Mint
             item
           end
 
-        head_comments, body, tail_comments = block_with_comments(
-          opening_bracket: FunctionExpectedOpeningBracket,
-          closing_bracket: FunctionExpectedClosingBracket
-        ) do
-          expression! FunctionExpectedExpression
-        end
+        body =
+          code_block
+
+        # head_comments, body, tail_comments = block_with_comments(
+        #   opening_bracket: FunctionExpectedOpeningBracket,
+        #   closing_bracket: FunctionExpectedClosingBracket
+        # ) do
+        #   expression! FunctionExpectedExpression
+        # end
 
         end_position = position
 
         whitespace
 
         self << Ast::Function.new(
+          head_comments: [] of Ast::Comment,
+          tail_comments: [] of Ast::Comment,
           body: body.as(Ast::Expression),
-          head_comments: head_comments,
-          tail_comments: tail_comments,
           arguments: arguments,
           from: start_position,
           comment: comment,

src/parsers/statement.cr

@@ -1,6 +1,6 @@
 module Mint
   class Parser
-    def statement(parent : Ast::Statement::Parent) : Ast::Statement?
+    def statement(parent : Ast::Statement::Parent, require_name : Bool = false) : Ast::Statement?
       start do |start_position|
         target = start do
           value = variable(track: false) || tuple_destructuring
@@ -11,6 +11,7 @@ module Mint
           value
         end
 
+        next if require_name && !target
         body = expression
 
         next unless body

src/parsers/tuple_destructuring.cr

@@ -8,6 +8,7 @@ module Mint
           next unless char! '{'
           value = tuple_destructuring || variable
           whitespace
+          next if char.in?('|', '=') # Don't parse record or record update as tuple destructuring
           char! ','
           whitespace
           value

src/type_checkers/function.cr

@@ -17,6 +17,10 @@ module Mint
       Comparer.normalize(defined_type)
     end
 
+    def check(node : Ast::Block) : Checkable
+      resolve node.expression
+    end
+
     def check(node : Ast::Function) : Checkable
       scope node do
         scope node.where.try(&.statements) || [] of Ast::WhereStatement do