[WIP] Arithmetic with Overflow

bin/ci

@@ -74,7 +74,8 @@ prepare_system() {
 
 build() {
   with_build_env 'make std_spec clean'
-  with_build_env 'make crystal std_spec compiler_spec docs'
+  with_build_env 'make crystal'
+  with_build_env 'make std_spec compiler_spec docs FLAGS=--overflow-checked'
   with_build_env 'find samples -name "*.cr" | xargs -L 1 ./bin/crystal build --no-codegen'
   with_build_env './bin/crystal tool format --check samples spec src'
 }

spec/compiler/codegen/overflow_check_scope_spec.cr

@@ -0,0 +1,327 @@
+require "../../spec_helper"
+
+def checked_run(code)
+  run(code, overflow_check: Crystal::OverflowCheckScope::Policy::Checked)
+end
+
+def unchecked_run(code)
+  run(code, overflow_check: Crystal::OverflowCheckScope::Policy::Unchecked)
+end
+
+describe "Code gen: overflow check scope" do
+  describe "for add" do
+    it "can be unchecked" do
+      checked_run(%(
+        unchecked { 2147483647_i32 + 1_i32 }
+      )).to_i.should eq(-2147483648_i32)
+    end
+
+    it "can be checked " do
+      unchecked_run(%(
+        require "prelude"
+
+        x = 0
+        begin
+          checked { 2147483647_i32 + 1_i32 }
+          x = 1
+        rescue OverflowError
+          x = 2
+        end
+        x
+      )).to_i.should eq(2)
+    end
+
+    {% for type in [UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64] %}
+      it "wrap around if unchecked for {{type}}" do
+        unchecked_run(%(
+          require "prelude"
+          {{type}}::MAX + {{type}}.new(1) == {{type}}::MIN
+        )).to_b.should be_true
+      end
+
+      it "raises if checked for {{type}}" do
+        checked_run(%(
+          require "prelude"
+          begin
+            {{type}}::MAX + {{type}}.new(1)
+            0
+          rescue OverflowError
+            1
+          end
+        )).to_i.should eq(1)
+      end
+
+      it "wrap around if unchecked for {{type}} + Int64" do
+        unchecked_run(%(
+          require "prelude"
+          {{type}}::MAX + 1_i64 == {{type}}::MIN
+        )).to_b.should be_true
+      end
+
+      it "raises if checked for {{type}} + Int64" do
+        checked_run(%(
+          require "prelude"
+          begin
+            {{type}}::MAX + 1_i64
+            0
+          rescue OverflowError
+            1
+          end
+        )).to_i.should eq(1)
+      end
+    {% end %}
+  end
+
+  describe "for sub" do
+    it "can be unchecked" do
+      checked_run(%(
+        unchecked { -2147483648_i32 - 1_i32 }
+      )).to_i.should eq(2147483647_i32)
+    end
+
+    it "can be checked " do
+      unchecked_run(%(
+        require "prelude"
+
+        x = 0
+        begin
+          checked { -2147483648_i32 - 1_i32 }
+          x = 1
+        rescue OverflowError
+          x = 2
+        end
+        x
+      )).to_i.should eq(2)
+    end
+
+    {% for type in [UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64] %}
+      it "wrap around if unchecked for {{type}}" do
+        unchecked_run(%(
+          require "prelude"
+          {{type}}::MIN - {{type}}.new(1) == {{type}}::MAX
+        )).to_b.should be_true
+      end
+
+      it "raises if checked for {{type}}" do
+        checked_run(%(
+          require "prelude"
+          begin
+            {{type}}::MIN - {{type}}.new(1)
+            0
+          rescue OverflowError
+            1
+          end
+        )).to_i.should eq(1)
+      end
+
+      it "wrap around if unchecked for {{type}} - Int64" do
+        unchecked_run(%(
+          require "prelude"
+          {{type}}::MIN - 1_i64 == {{type}}::MAX
+        )).to_b.should be_true
+      end
+
+      it "raises if checked for {{type}} - Int64" do
+        checked_run(%(
+          require "prelude"
+          begin
+            {{type}}::MIN - 1_i64
+            0
+          rescue OverflowError
+            1
+          end
+        )).to_i.should eq(1)
+      end
+    {% end %}
+  end
+
+  describe "for mul" do
+    it "can be unchecked" do
+      checked_run(%(
+        unchecked { 2147483647_i32 * 2_i32 }
+      )).to_i.should eq(-2_i32)
+    end
+
+    it "can be checked " do
+      unchecked_run(%(
+        require "prelude"
+
+        x = 0
+        begin
+          checked { 2147483647_i32 * 2_i32 }
+          x = 1
+        rescue OverflowError
+          x = 2
+        end
+        x
+      )).to_i.should eq(2)
+    end
+
+    {% for type in [UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64] %}
+      it "wrap around if unchecked for {{type}}" do
+        unchecked_run(%(
+          require "prelude"
+          ({{type}}::MAX / {{type}}.new(2) + {{type}}.new(1)) * {{type}}.new(2) == {{type}}::MIN
+        )).to_b.should be_true
+      end
+
+      it "raises if checked for {{type}}" do
+        checked_run(%(
+          require "prelude"
+          begin
+            ({{type}}::MAX / {{type}}.new(2) + {{type}}.new(1)) * {{type}}.new(2)
+            0
+          rescue OverflowError
+            1
+          end
+        )).to_i.should eq(1)
+      end
+
+      it "wrap around if unchecked for {{type}} + Int64" do
+        unchecked_run(%(
+          require "prelude"
+          ({{type}}::MAX / {{type}}.new(2) + {{type}}.new(1)) * 2_i64 == {{type}}::MIN
+        )).to_b.should be_true
+      end
+
+      it "raises if checked for {{type}} + Int64" do
+        checked_run(%(
+          require "prelude"
+          begin
+            ({{type}}::MAX / {{type}}.new(2) + {{type}}.new(1)) * 2_i64
+            0
+          rescue OverflowError
+            1
+          end
+        )).to_i.should eq(1)
+      end
+    {% end %}
+  end
+
+  it "obey default checked" do
+    checked_run(%(
+      require "prelude"
+
+      x = 0
+      begin
+        a = 2147483647_i32 + 1_i32
+        x = 1
+      rescue OverflowError
+        x = 2
+      end
+      x
+    )).to_i.should eq(2)
+  end
+
+  it "obey default unchecked" do
+    unchecked_run(%(
+      2147483647_i32 + 1_i32
+    )).to_i.should eq(-2147483648_i32)
+  end
+
+  it "is obeyed in return" do
+    checked_run(%(
+      def inc(v)
+        unchecked {
+          return v + 1_i8
+        }
+      end
+
+      inc(127_i8)
+    )).to_i.should eq(-128)
+  end
+
+  it "can be nested" do
+    unchecked_run(%(
+      require "prelude"
+
+      begin
+        checked { unchecked { 2147483647_i32 + 1_i32 } + 2147483647_i32 + 2147483647_i32 + 2_i32 }
+        0
+      rescue OverflowError
+        1
+      end
+    )).to_i.should eq(1)
+  end
+
+  describe "work at lexical scope." do
+    it "is not forwarded to function calls" do
+      checked_run(%(
+        require "prelude"
+
+        def inc_checked(v)
+          v + 1_i8
+        end
+
+        def twice(v)
+          unchecked { inc_checked(inc_checked(v)) }
+        end
+
+        begin
+          twice(126_i8)
+          1
+        rescue OverflowError
+          2
+        end
+      )).to_i.should eq(2)
+
+      unchecked_run(%(
+        require "prelude"
+
+        def inc_unchecked(v)
+          v + 1_i8
+        end
+
+        def twice(v)
+          checked { inc_unchecked(inc_unchecked(v)) }
+        end
+
+        begin
+          twice(126_i8)
+          1
+        rescue OverflowError
+          2
+        end
+      )).to_i.should eq(1)
+    end
+
+    it "is not forwarded to blocks yields" do
+      unchecked_run(%(
+        require "prelude"
+
+        def inc_unchecked
+          yield + 1_i8
+        end
+
+        def foo
+          checked {
+            inc_unchecked { 127_i8 }
+          }
+        end
+
+        foo
+      )).to_i.should eq(-128_i8)
+    end
+
+    it "is forwarded to blocks" do
+      unchecked_run(%(
+        require "prelude"
+
+        def inc_unchecked(v)
+          yield v
+        end
+
+        def foo
+          checked {
+            inc_unchecked(127_i8) { |v| v + 1_i8 }
+          }
+          1
+        rescue OverflowError
+          0
+        end
+
+        foo
+      )).to_i.should eq(0)
+    end
+  end
+end

spec/compiler/parser/parser_spec.cr

@@ -126,6 +126,9 @@ module Crystal
     it_parses "foo[1] /2", Call.new(Call.new("foo".call, "[]", 1.int32), "/", 2.int32)
     it_parses "[1] /2", Call.new(([1.int32] of ASTNode).array, "/", 2.int32)
 
+    it_parses "checked { 1 + 2 }", OverflowCheckScope.new(OverflowCheckScope::Policy::Checked, Expressions.from([Call.new(1.int32, "+", 2.int32)] of ASTNode))
+    it_parses "unchecked { 1 + 2 }", OverflowCheckScope.new(OverflowCheckScope::Policy::Unchecked, Expressions.from([Call.new(1.int32, "+", 2.int32)] of ASTNode))
+
     it_parses "!1", Not.new(1.int32)
     it_parses "- 1", Call.new(1.int32, "-")
     it_parses "+ 1", Call.new(1.int32, "+")
@@ -181,6 +184,7 @@ module Crystal
       extend class struct module enum while until return
       next break lib fun alias pointerof sizeof
       instance_sizeof typeof private protected asm out
+      checked unchecked
       end
     ).each do |kw|
       assert_syntax_error "def foo(#{kw}); end", "cannot use '#{kw}' as an argument name", 1, 9
@@ -1643,6 +1647,8 @@ module Crystal
       assert_end_location "extend Foo"
       assert_end_location "1.as(Int32)"
       assert_end_location "puts obj.foo"
+      assert_end_location "checked { 1 + 1 }"
+      assert_end_location "unchecked { 1 + 1 }"
 
       assert_syntax_error %({"a" : 1}), "space not allowed between named argument name and ':'"
       assert_syntax_error %({"a": 1, "b" : 2}), "space not allowed between named argument name and ':'"

spec/compiler/semantic/overflow_check_scope_spec.cr

@@ -0,0 +1,10 @@
+require "../../spec_helper"
+
+describe "Semantic: overflow check scope" do
+  it "type block by expression" do
+    assert_type("checked { 1 }") { int32 }
+    assert_type("unchecked { 1 }") { int32 }
+    assert_type("checked { 1 + 2; '1' }") { char }
+    assert_type("def foo; unchecked { return 1 }; end; foo") { int32 }
+  end
+end