Add comments justifying use of subtyping, closes #15273

Author: josevalim

lib/elixir/lib/module/types/apply.ex

@@ -393,6 +393,7 @@ defmodule Module.Types.Apply do
     case sized_order(name, left, right, expected) do
       {arg, expected, precise?, return} ->
         {actual, context} = of_fun.(arg, expected, expr, stack, context)
+        # expected is a static type, so we can use subtype? rather than compatible?
         result = if precise? and subtype?(actual, expected), do: return, else: boolean()
         {result, context}
 
@@ -525,9 +526,10 @@ defmodule Module.Types.Apply do
           {arg_type, context} = of_fun.(arg, expected, expr, stack, context)
 
           cond do
-            # Return a precise result
-            singleton? and subtype?(arg_type, expected) ->
-              {return(return, [arg_type, expected], stack), context}
+            # expected can have dynamic terms but, since we have verified
+            # them to be singletons, we can compute the upper bound.
+            singleton? and subtype?(arg_type, upper_bound(expected)) ->
+              {return, context}
 
             # Singleton types with reverse polarity are negated, so we don't check for disjoint
             (singleton? and not polarity) or not is_warning(stack) ->
@@ -608,6 +610,8 @@ defmodule Module.Types.Apply do
           end
 
         {actual, context} = of_fun.(arg, expected, expr, stack, context)
+
+        # expected here is a static type, so subtyping relation is fine
         result = if precise? and subtype?(actual, expected), do: return, else: boolean()
 
         # We can skip return compare because literal is always an integer,
@@ -635,7 +639,7 @@ defmodule Module.Types.Apply do
         if singleton?(type) do
           expected = if polarity, do: type, else: negation(type)
           {arg_type, context} = of_fun.(arg, expected, expr, stack, context)
-          result = if subtype?(arg_type, expected), do: return, else: boolean()
+          result = if subtype?(arg_type, upper_bound(expected)), do: return, else: boolean()
 
           # Because reverse polarity means we will infer negated types
           # (which are naturally disjoint), we skip checks in such cases

lib/elixir/lib/module/types/pattern.ex

@@ -18,6 +18,7 @@ defmodule Module.Types.Pattern do
   defp empty_previous?({[], _}), do: true
   defp empty_previous?({[_ | _], _}), do: false
 
+  # Previous is always an upper bound (static), so we can use subtype?
   defp previous_subtype?(_, {[], _}), do: false
   defp previous_subtype?([], _), do: true
   defp previous_subtype?(args, {_, descr}), do: subtype?(args_to_previous(args), descr)
@@ -1258,12 +1259,12 @@ defmodule Module.Types.Pattern do
 
   defp of_remote(fun, _args, call, expected, stack, context)
        when fun in [:and, :or, :andalso, :orelse] do
-    {both_domain, abort_domain, always_rhs?} =
+    {boolean, abort_domain, always_rhs?} =
       case fun do
-        :andalso -> {@atom_true, @atom_false, false}
-        :orelse -> {@atom_false, @atom_true, false}
-        :and -> {@atom_true, @atom_false, true}
-        :or -> {@atom_false, @atom_true, true}
+        :andalso -> {true, @atom_false, false}
+        :orelse -> {false, @atom_true, false}
+        :and -> {true, @atom_false, true}
+        :or -> {false, @atom_true, true}
       end
 
     # If we have multiple operations in a row,
@@ -1279,7 +1280,7 @@ defmodule Module.Types.Pattern do
     # only be true if both clauses are executed, so we know the first
     # argument has to be true and the second has to be expected.
     cond do
-      is_nil(context.pattern_info) or subtype?(expected, both_domain) ->
+      is_nil(context.pattern_info) or booleaness(expected) == {boolean, :always} ->
         of_logical_all([left | right], true, expected, abort_domain, stack, context)
 
       right == [] ->