fix test: single function in overload

Author: auht

shared/src/main/scala/mlscript/TyperDatatypes.scala

@@ -744,15 +744,17 @@ abstract class TyperDatatypes extends TyperHelpers { Typer: Typer =>
     }
     def mk(ov: Overload)(implicit lvl: Level): FunctionType = {
       def unwrap(t: ST): ST = t.map(unwrap)
-      val f = ov.mapAlts(unwrap)(unwrap)
-      val (t, tvs, constrs) = lcgFunction(f.alts.head, f.alts.tail)(ov.prov, lvl)
-      val tsc = new TupleSetConstraints(MutSet.empty ++ constrs.transpose, tvs)(ov.prov)
-      tvs.zipWithIndex.foreach { case (tv, i) =>
-        tv.lbtsc = S((tsc, i))
-        tv.ubtsc = S((tsc, i))
+      if (ov.alts.tail.isEmpty) ov.alts.head else {
+        val f = ov.mapAlts(unwrap)(unwrap)
+        val (t, tvs, constrs) = lcgFunction(f.alts.head, f.alts.tail)(ov.prov, lvl)
+        val tsc = new TupleSetConstraints(MutSet.empty ++ constrs.transpose, tvs)(ov.prov)
+        tvs.zipWithIndex.foreach { case (tv, i) =>
+          tv.lbtsc = S((tsc, i))
+          tv.ubtsc = S((tsc, i))
+        }
+        println(s"TSC mk: ${tsc.tvs} in ${tsc.constraints}")
+        t
       }
-      println(s"TSC mk: ${tsc.tvs} in ${tsc.constraints}")
-      t
     }
   }
 }

shared/src/main/scala/mlscript/TyperHelpers.scala

@@ -983,15 +983,15 @@ abstract class TyperHelpers { Typer: Typer =>
     def getVars: SortedSet[TypeVariable] = getVarsImpl(includeBounds = true)
 
     def showBounds: String =
-      getVars.iterator.filter(tv => tv.assignedTo.nonEmpty || (tv.upperBounds ++ tv.lowerBounds).nonEmpty || (tv.lbtsc.fold(false)(!_._1.tvs.contains(tv)))).map {
+      getVars.iterator.filter(tv => tv.assignedTo.nonEmpty || (tv.upperBounds ++ tv.lowerBounds).nonEmpty || (tv.lbtsc.isDefined && tv.ubtsc.isEmpty)).map {
       case tv @ AssignedVariable(ty) => "\n\t\t" + tv.toString + " := " + ty
       case tv => ("\n\t\t" + tv.toString
           + (if (tv.lowerBounds.isEmpty) "" else " :> " + tv.lowerBounds.mkString(" | "))
           + (if (tv.upperBounds.isEmpty) "" else " <: " + tv.upperBounds.mkString(" & "))
           + tv.lbtsc.fold(""){ case (tsc, i) => " :> " + tsc.tvs(i) } )
       }.mkString + {
         val visited: MutSet[TV] = MutSet.empty
-        getVars.iterator.filter(tv => tv.lbtsc.fold(false)(_._1.tvs.contains(tv))).map {
+        getVars.iterator.filter(tv => tv.ubtsc.isDefined).map {
           case tv if visited.contains(tv) => ""
           case tv =>
             visited ++= tv.lbtsc.fold(Nil: Ls[TV])(_._1.tvs)

shared/src/test/diff/nu/ArrayProg.mls

@@ -136,7 +136,6 @@ fun s: (([Numbr,Numbr] -> Int) & ([Vectr,Vectr] -> Int),)
 fun s: ([Numbr,Numbr] -> Int) & ([Vectr,Vectr] -> Int)
 //│ fun s: (Numbr | Vectr, Numbr | Vectr) -> Int
 
-
 s(Vectr([]),Vectr([]))
 //│ Int
 //│ res
@@ -155,7 +154,7 @@ module A {
 //│ }
 
 A.g(0)
-//│ Int | Str
+//│ Int
 //│ res
 //│     = 0
 

shared/src/test/diff/nu/WeirdUnions.mls

@@ -47,14 +47,24 @@ fun f: (Str => Str) & ((Str, Int) => Int)
 //│ fun f: Str -> Str & (Str, Int) -> Int
 
 // * ...resulting in approximation at call sites (we don't handle overloading)
+:e // TODO
 f("abc", "abc")
-//│ Int | Str
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.51: 	f("abc", "abc")
+//│ ║        	^^^^^^^^^^^^^^^
+//│ ╟── argument list of type `["abc", "abc"]` does not match type `?a`
+//│ ║  l.51: 	f("abc", "abc")
+//│ ║        	 ^^^^^^^^^^^^^^
+//│ ╟── Note: constraint arises from function type:
+//│ ║  l.46: 	fun f: (Str => Str) & ((Str, Int) => Int)
+//│ ╙──      	                      ^^^^^^^^^^^^^^^^^^^
+//│ error
 //│ res
 //│     = <no result>
 //│       f is not implemented
 
 f("abcabc")
-//│ Int | Str
+//│ Str
 //│ res
 //│     = <no result>
 //│       f is not implemented
@@ -71,19 +81,19 @@ let r = if true then id else (x, y) => [y, x]
 r(error)
 r(error, error)
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.71: 	r(error)
+//│ ║  l.81: 	r(error)
 //│ ║        	^^^^^^^^
 //│ ╟── argument of type `[nothing]` does not match type `[?a, ?b]`
-//│ ║  l.71: 	r(error)
+//│ ║  l.81: 	r(error)
 //│ ║        	 ^^^^^^^
 //│ ╟── Note: constraint arises from tuple literal:
-//│ ║  l.65: 	let r = if true then id else (x, y) => [y, x]
+//│ ║  l.75: 	let r = if true then id else (x, y) => [y, x]
 //│ ╙──      	                              ^^^^
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.72: 	r(error, error)
+//│ ║  l.82: 	r(error, error)
 //│ ║        	^^^^^^^^^^^^^^^
 //│ ╟── argument list of type `[nothing, nothing]` does not match type `[?a]`
-//│ ║  l.72: 	r(error, error)
+//│ ║  l.82: 	r(error, error)
 //│ ╙──      	 ^^^^^^^^^^^^^^
 //│ error | [nothing, nothing]
 //│ res
@@ -106,7 +116,7 @@ r of [0, 1]
 
 // Also currently parses the same:
 let r = if true then id else [x, y] => [y, x]
-//│ let r: forall 'a 'b 'c. (['b, 'c] & 'a) -> (['c, 'b] | 'a)
+//│ let r: forall 'a 'b 'c. (['a, 'b] & 'c) -> (['b, 'a] | 'c)
 //│ r
 //│   = [Function: id]