Allow unifing of promise branches in some cases.

Author: gdotdesign

spec/examples/block

@@ -6,3 +6,39 @@ component Main {
     <span>"Hello"</span>
   }
 }
+
+
+-------------------------------------------------------------------------------
+type Maybe(value) {
+  Just(value)
+  Nothing
+}
+
+component Main {
+  fun render : String {
+    {
+      let Just = Maybe.Just("hello") or return ""
+
+      `` as Promise(String)
+    }
+
+    ""
+  }
+}
+-------------------------------------------------statement_return_type_mismatch
+type Maybe(value) {
+  Just(value)
+  Nothing
+}
+
+component Main {
+  fun render : String {
+    {
+      let Just = Maybe.Just("hello") or return `` as Promise(String)
+
+      ""
+    }
+
+    ""
+  }
+}

spec/examples/case

@@ -283,3 +283,18 @@ component Main {
     ""
   }
 }
+-------------------------------------------------------------------------------
+component Main {
+  fun render : String {
+    case 0 {
+      0 => `` as Promise(Void)
+      1 => void
+      2 => `` as Promise(Void)
+      3 => void
+      4=> `` as Promise(Void)
+      => void
+    }
+
+    ""
+  }
+}

spec/examples/if

@@ -199,3 +199,33 @@ component Main {
     }
   }
 }
+-------------------------------------------------------------------------------
+component Main {
+  fun test : Promise(Void) {
+    if true {
+      `` as Promise(Void)
+    } else {
+      Void
+    }
+  }
+
+  fun render : String {
+    test()
+    ""
+  }
+}
+-------------------------------------------------------------------------------
+component Main {
+  fun test : Promise(Void) {
+    if true {
+      Void
+    } else {
+      `` as Promise(Void)
+    }
+  }
+
+  fun render : String {
+    test()
+    ""
+  }
+}

src/type_checker/comparer.cr

@@ -7,6 +7,30 @@ module Mint
         targets.any? { |target| compare(node, target) }
       end
 
+      def compare_as_promises(node1, node2, *, first_only : Bool = false)
+        promise = false
+
+        if node1.name != node2.name &&
+           ((node1.name == "Promise" && node1.parameters.size == 1) ||
+           (node2.name == "Promise" && node2.parameters.size == 1 && !first_only))
+          node1 =
+            node1.parameters.first if node1.name == "Promise"
+
+          node2 =
+            node2.parameters.first if node2.name == "Promise" && !first_only
+
+          promise = true
+        end
+
+        compare(node1, node2).try do |resolved|
+          if promise
+            Type.new("Promise", [resolved] of Checkable)
+          else
+            resolved
+          end
+        end
+      end
+
       def compare(node1, node2, *, expand : Bool = false)
         prune(unify(fresh(prune(node1)), fresh(prune(node2)), expand: expand))
       rescue

src/type_checkers/block.cr

@@ -65,7 +65,7 @@ module Mint
             snippet "I was expecting:", last
             snippet "The return call in question is here:", return_value
             snippet "The returned value of the block is here:", expressions.last
-          end unless Comparer.compare(last, type)
+          end unless Comparer.compare_as_promises(last, type, first_only: true)
         end
 
         if fallback = node.fallback
@@ -79,7 +79,7 @@ module Mint
             snippet "I was expecting:", last
             snippet "The fallback expression in question is here:", fallback
             snippet "The returned value of the block is here:", expressions.last
-          end unless Comparer.compare(last, type)
+          end unless Comparer.compare_as_promises(last, type, first_only: true)
         end
 
         if async.includes?(node) && last.name != "Promise"

src/type_checkers/case.cr

@@ -224,7 +224,7 @@ module Mint
               resolve branch, condition
 
             unified_branch =
-              Comparer.compare(type, resolved)
+              Comparer.compare_as_promises(resolved, type)
 
             error! :case_branch_not_matches do
               block do

src/type_checkers/if.cr

@@ -78,7 +78,9 @@ module Mint
 
           snippet "The value for the else branch is here:",
             error_node.as(Ast::Node)
-        end unless Comparer.compare(truthy, falsy)
+        end unless resolved = Comparer.compare_as_promises(truthy, falsy)
+
+        resolved
       else
         error! :if_expected_else do
           block do
@@ -94,9 +96,9 @@ module Mint
           snippet truthy
           snippet node
         end unless Comparer.matches_any?(truthy, VALID_IF_TYPES)
-      end
 
-      truthy
+        truthy
+      end
     end
   end
 end