crystal-lang · Sep 22, 2016 · Sep 22, 2016
Showing with 31 additions and 2 deletions.

+14 −0 spec/compiler/semantic/block_spec.cr

+15 −2 src/compiler/crystal/semantic/main_visitor.cr

+2 −0 src/gc/boehm.cr
diff --git a/spec/compiler/semantic/block_spec.cr b/spec/compiler/semantic/block_spec.cr
@@ -1331,4 +1331,18 @@ describe "Block inference" do
       Foo.new(1).foo { |x| {x, x} }
       )) { tuple_of([tuple_of([int32, int32]), tuple_of([int32, int32]).metaclass]) }
   end
+
+  it "correctly types unpacked tuple block arg after block (#3339)" do
+    assert_type(%(
+      def foo
+        yield({""})
+      end
+
+      i = 1
+      foo do |(i)|
+
+      end
+      i
+      ), inject_primitives: false) { int32 }
+  end
 end
diff --git a/src/compiler/crystal/semantic/main_visitor.cr b/src/compiler/crystal/semantic/main_visitor.cr
@@ -888,19 +888,29 @@ module Crystal
       arg_counter = 0
       body_exps = node.body.as?(Expressions).try(&.expressions)
 
+      # Variables that we don't want to get their type merged
+      # with local variables before the block occurrence:
+      # mainly block arguments (locally override vars), but
+      # also block arguments that result from tuple unpacking
+      # that the parser currently generated as local assignments.
+      ignored_vars_after_block = nil
+
       meta_vars = @meta_vars.dup
       node.args.each do |arg|
         # The parser generates __argN block arguments for tuple unpacking,
         # and they need a special treatment because they shouldn't override
         # local variables. So we search the unpacked vars in the body.
         if arg.name.starts_with?("__arg") && body_exps
+          ignored_vars_after_block = node.args.dup
+
           while arg_counter < body_exps.size &&
                 (assign = body_exps[arg_counter]).is_a?(Assign) &&
                 (target = assign.target).is_a?(Var) &&
                 (call = assign.value).is_a?(Call) &&
                 (call_var = call.obj).is_a?(Var) &&
                 call_var.name == arg.name
             bind_block_var(node, target, meta_vars, before_block_vars)
+            ignored_vars_after_block << Var.new(target.name)
             arg_counter += 1
           end
         end
@@ -934,8 +944,9 @@ module Crystal
       @block_nest -= 1
 
       # Check re-assigned variables and bind them.
-      bind_vars block_visitor.vars, node.vars
-      bind_vars block_visitor.vars, node.after_vars, node.args
+      ignored_vars_after_block ||= node.args
+      bind_vars block_visitor.vars, node.vars, ignored_vars_after_block
+      bind_vars block_visitor.vars, node.after_vars, ignored_vars_after_block
 
       # Special vars, even if only assigned inside a block,
       # must be inside the def's metavars.
@@ -949,6 +960,8 @@ module Crystal
 
       node.bind_to node.body
 
+      # pp node, @vars
+
       false
     end
 

diff --git a/src/gc/boehm.cr b/src/gc/boehm.cr
@@ -50,6 +50,8 @@ lib LibGC
   # GC_on_collection_event isn't exported.  Can't collect totals without it.
   # bytes_allocd, heap_size, unmapped_bytes are macros
 
+  fun size = GC_size(addr : Void*) : LibC::SizeT
+
   # Boehm GC requires to use GC_pthread_create and GC_pthread_join instead of pthread_create and pthread_join
   fun pthread_create = GC_pthread_create(thread : LibC::PthreadT*, attr : Void*, start : Void* ->, arg : Void*) : LibC::Int
   fun pthread_join = GC_pthread_join(thread : LibC::PthreadT, value : Void**) : LibC::Int