Implement assert statement

Author: oprypin

src/compiler/crystal/semantic/ast.cr

@@ -538,7 +538,7 @@ module Crystal
                    ArrayLiteral HashLiteral RegexLiteral RangeLiteral
                    Case StringInterpolation
                    MacroExpression MacroIf MacroFor MultiAssign
-                   SizeOf InstanceSizeOf Global Require Select) %}
+                   SizeOf InstanceSizeOf Global Require Select Assert) %}
     class {{name.id}}
       include ExpandableNode
     end

src/compiler/crystal/semantic/literal_expander.cr

@@ -528,6 +528,48 @@ module Crystal
       end
     end
 
+    def expand(node : Assert)
+      transformer = AssertExprTransformer.new(@program)
+      (expr = node.expression).transform(visitor)
+
+      string = [StringLiteral.new(source.inspect).at(node)] of ASTNode
+
+      transformer.items.each do |assign|
+        location = case (val = assign.value)
+        when Crystal::Call
+          val.name_column_number
+        else
+          val.location.column_number
+        end - 1
+
+        string << StringLiteral.new(" " * location + "^").at(node) << assign.value
+      end
+
+      Unless.new(expr,
+        Call.new(nil, "raise",
+          Call.new(Path.global("AssertionFailed"), "new",
+            StringInterpolation.new(string).at(node)
+          ).at(node)
+        ).at(node)
+      ).at(node)
+    end
+
+    class AssertExprTransformer < Transformer
+      getter items = [] of Assign
+
+      def initialize(@program : Program)
+      end
+
+      def transform(node : ASTNode)
+        unless node.class.name.ends_with? "Literal"
+          if node.location
+            items << (node = Assign.new(Var.new(@program.new_temp_var), node))
+          end
+        end
+        node
+      end
+    end
+
     # Transform a multi assign into many assigns.
     def expand(node : MultiAssign)
       # From:

src/compiler/crystal/semantic/main_visitor.cr

@@ -2662,6 +2662,11 @@ module Crystal
       false
     end
 
+    def visit(node : Assert)
+      node.expression.accept self
+      false
+    end
+
     def visit(node : MultiAssign)
       expand(node)
       false

src/compiler/crystal/syntax/ast.cr

@@ -1150,6 +1150,24 @@ module Crystal
     def_equals_and_hash @whens, @else
   end
 
+  class Assert < ASTNode
+    property expression : ASTNode
+    property source : String
+
+    def initialize(@expression, @source)
+    end
+
+    def accept_children(visitor)
+      expression.accept visitor
+    end
+
+    def clone_without_location
+      Assert.new(@expression, @source)
+    end
+
+    def_equals_and_hash @expression
+  end
+
   # Node that represents an implicit obj in:
   #
   #     case foo

src/compiler/crystal/syntax/lexer.cr

@@ -700,6 +700,11 @@ module Crystal
           when 'm'
             next_char
             return check_ident_or_keyword(:asm, start)
+          when 's'
+            next_char
+            if next_char == 'e' && next_char == 'r' && next_char == 't'
+              return check_ident_or_keyword(:assert, start)
+            end
           when '?'
             next_char
             next_char

src/compiler/crystal/syntax/parser.cr

@@ -1032,6 +1032,8 @@ module Crystal
           check_type_declaration { parse_case }
         when :select
           check_type_declaration { parse_select }
+        when :assert
+          check_type_declaration { parse_assert }
         when :if
           check_type_declaration { parse_if }
         when :ifdef
@@ -2555,6 +2557,17 @@ module Crystal
       end
     end
 
+    def parse_assert
+      location = @token.location
+
+      next_token_skip_space
+
+      pos = reader.pos
+      expr = parse_expression
+      source = reader.string[pos...@reader.pos]
+      Assert.new(expr, source).at(location)
+    end
+
     def parse_include
       parse_include_or_extend Include
     end

src/compiler/crystal/syntax/to_s.cr

@@ -1282,6 +1282,13 @@ module Crystal
       false
     end
 
+    def visit(node : Assert)
+      @str << keyword("assert")
+      @str << " "
+      node.expression.accept self
+      false
+    end
+
     def visit(node : ImplicitObj)
       false
     end

src/compiler/crystal/syntax/transformer.cr

@@ -232,6 +232,16 @@ module Crystal
       node
     end
 
+    def transform(node : Assert)
+      new_expr = node.expression.transform(self)
+      unless new_expr == node.expression
+        node.expression = new_expr
+        node.source = new_expr.to_s
+      end
+
+      node
+    end
+
     def transform(node : ImplicitObj)
       node
     end

src/compiler/crystal/tools/formatter.cr

@@ -3328,6 +3328,13 @@ module Crystal
       false
     end
 
+    def visit(node : Assert)
+      write_keyword :assert, " "
+      accept node.expression
+
+      false
+    end
+
     def visit(node : Attribute)
       write_token :"@["
       skip_space_or_newline