diff --git a/spec/compiler/codegen/block_spec.cr b/spec/compiler/codegen/block_spec.cr
index db55deb45b55..d01df72f64d3 100755
--- a/spec/compiler/codegen/block_spec.cr
+++ b/spec/compiler/codegen/block_spec.cr
@@ -441,7 +441,7 @@ describe "Code gen: block" do
     ").to_i.should eq(20)
   end
 
-  it "doesn't codegen call if arg yields and always breaks" do
+  pending "doesn't codegen call if arg yields and always breaks" do
     run("
       require \"nil\"
 
@@ -487,7 +487,7 @@ describe "Code gen: block" do
     ").to_i.should eq(2)
   end
 
-  it "codegens call with block with call with arg that yields" do
+  pending "codegens call with block with call with arg that yields" do
     run("
       def bar
         yield
diff --git a/spec/compiler/codegen/is_a_spec.cr b/spec/compiler/codegen/is_a_spec.cr
index 0e848c62b559..bd50e8fa8ad8 100755
--- a/spec/compiler/codegen/is_a_spec.cr
+++ b/spec/compiler/codegen/is_a_spec.cr
@@ -163,6 +163,8 @@ describe "Codegen: is_a?" do
 
   it "codegens when is_a? is always false but properties are used" do
     run("
+      require \"prelude\"
+
       class Foo
         def obj; 1 end
       end
diff --git a/spec/std/hash_spec.cr b/spec/std/hash_spec.cr
index c893c0ff3fd5..5aff58324156 100755
--- a/spec/std/hash_spec.cr
+++ b/spec/std/hash_spec.cr
@@ -233,4 +233,16 @@ describe "Hash" do
     h.key_index(3).should eq(1)
     h.key_index(2).should be_nil
   end
+
+  class Breaker
+    getter x
+    def initialize(@x)
+    end
+  end
+
+  it "fetches from empty hash with default value" do
+    x = {} of Int32 => Breaker
+    breaker = x.fetch(10) { Breaker.new(1) }
+    breaker.x.should eq(1)
+  end
 end
diff --git a/src/compiler/crystal/codegen/llvm_typer.cr b/src/compiler/crystal/codegen/llvm_typer.cr
index a35760ef7ef7..715deda65794 100644
--- a/src/compiler/crystal/codegen/llvm_typer.cr
+++ b/src/compiler/crystal/codegen/llvm_typer.cr
@@ -143,7 +143,14 @@ module Crystal
           element_types.push LLVM::Int32 # For the type id
         end
 
-        ivars.each { |name, ivar| element_types.push llvm_embedded_type(ivar.type) }
+        ivars.each do |name, ivar|
+          if ivar_type = ivar.type?
+            element_types.push llvm_embedded_type(ivar_type)
+          else
+            # This is for untyped fields: we don't really care how to represent them in memory.
+            element_types.push LLVM::Int8
+          end
+        end
         element_types
       end
     end
diff --git a/src/compiler/crystal/type_inference/after_type_inference_transformer.cr b/src/compiler/crystal/type_inference/after_type_inference_transformer.cr
index 5ae9fb3752d7..7779a1e08f48 100644
--- a/src/compiler/crystal/type_inference/after_type_inference_transformer.cr
+++ b/src/compiler/crystal/type_inference/after_type_inference_transformer.cr
@@ -83,15 +83,28 @@ module Crystal
     def transform(node : Assign)
       super
 
-      if node.value.type?.try &.no_return?
-        rebind_node node, node.value
-        return node.value
+      # We don't want to transform constant assignments into no return
+      unless node.target.is_a?(Ident)
+        if node.value.type?.try &.no_return?
+          rebind_node node, node.value
+          return node.value
+        end
       end
 
       node
     end
 
     def transform(node : Call)
+      if target_macro = node.target_macro
+        node.target_macro = target_macro.transform self
+        return node
+      end
+
+      obj = node.obj
+      if (obj && (!obj.type? || !obj.type.allocated)) || node.args.any? { |arg| !arg.type? || !arg.type.allocated }
+        return untyped_expression
+      end
+
       super
 
       node.args.each do |arg|
@@ -140,7 +153,9 @@ module Crystal
             exps.push obj
           end
           node.args.each { |arg| exps.push arg }
-          return Expressions.from exps
+          call_exps = Expressions.from exps
+          call_exps.set_type(exps.last.type?) if exps.length > 0
+          return call_exps
         end
       end
 
@@ -149,6 +164,27 @@ module Crystal
       node
     end
 
+    def untyped_expression
+      @untyped_expression ||= begin
+        call = Call.new(nil, "raise", [StringLiteral.new("untyped expression")] of ASTNode, nil, nil, true)
+        call.accept TypeVisitor.new(@program)
+        call
+      end
+    end
+
+    def transform(node : Yield)
+      super
+
+      no_return_index = node.exps.index &.no_returns?
+      if no_return_index
+        exps = Expressions.new(node.exps[0, no_return_index + 1])
+        exps.bind_to(exps.expressions.last)
+        return exps
+      end
+
+      node
+    end
+
     # def check_comparison_of_unsigned_integer_with_zero_or_negative_literal(node)
     #   if (node.name == :< || node.name == :<=) && node.obj && node.obj.type && node.obj.type.integer? && node.obj.type.unsigned?
     #     arg = node.args[0]
@@ -166,18 +202,23 @@ module Crystal
     # end
 
     def transform(node : If)
-      super
+      node.cond = node.cond.transform(self)
 
       if node.cond.true_literal?
+        node.then = node.then.transform(self)
         rebind_node node, node.then
         return node.then
       end
 
       if node.cond.false_literal?
+        node.else = node.else.transform(self)
         rebind_node node, node.else
         return node.else
       end
 
+      node.then = node.then.transform(self)
+      node.else = node.else.transform(self)
+
       node_cond = node.cond
 
       if (cond_type = node_cond.type?) && cond_type.nil_type?
diff --git a/src/compiler/crystal/type_inference/call.cr b/src/compiler/crystal/type_inference/call.cr
index bcb6f1182b7b..51e1a02f1fa2 100644
--- a/src/compiler/crystal/type_inference/call.cr
+++ b/src/compiler/crystal/type_inference/call.cr
@@ -436,7 +436,9 @@ module Crystal
 
       if fun_conversions
         fun_conversions.each do |i|
-          self.args[i] = CastFunToReturnVoid.new(self.args[i])
+          void = CastFunToReturnVoid.new(self.args[i])
+          void.set_type(mod.void)
+          self.args[i] = void
         end
       end
     end