add flag

Author: auht

shared/src/main/scala/mlscript/ConstraintSolver.scala

@@ -627,7 +627,7 @@ class ConstraintSolver extends NormalForms { self: Typer =>
               recLb(ar.inner, b.inner)
               rec(b.inner.ub, ar.inner.ub, false)
             case (LhsRefined(S(b: ArrayBase), ts, r, _), _) => reportError()
-            case (LhsRefined(S(ov: Overload), ts, r, trs), RhsBases(_, S(L(f: FunctionType)), _)) =>
+            case (LhsRefined(S(ov: Overload), ts, r, trs), RhsBases(_, S(L(f: FunctionType)), _)) if noApproximateOverload =>
               TupleSetConstraints.mk(ov, f) match {
                 case S(tsc) => if (!tsc.tvs.isEmpty && tsc.constraints.isEmpty) reportError()
                 case N => reportError()

shared/src/main/scala/mlscript/Typer.scala

@@ -34,6 +34,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool, val ne
   var constrainedTypes: Boolean = false
 
   var recordProvenances: Boolean = true
+  var noApproximateOverload: Boolean = false
 
   type Binding = Str -> SimpleType
   type Bindings = Map[Str, SimpleType]

shared/src/test/diff/basics/Intersections.fun

@@ -26,68 +26,84 @@ succ / foo(1)
 let foo = (Int => Int) & (Bool => Bool)
 //│ foo: int -> int & bool -> bool
 
-// used to return int & bool, equivalent to nothing
-// or approximated as int | bool in MLscript
-// overloaded function foo can now be used as either int -> int or bool -> bool
-foo(1)
+:e
+foo(1) // returns int & bool, equivalent to nothing
 succ / foo(1)
 foo(true)
 not / foo(true)
-//│ res: int
-//│ res: int
-//│ res: bool
-//│ res: bool
+//│ res: bool | int
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.31: 	succ / foo(1)
+//│ ║        	^^^^^^^^^^^^^
+//│ ╟── reference of type `bool` is not an instance of type `int`
+//│ ║  l.26: 	let foo = (Int => Int) & (Bool => Bool)
+//│ ║        	                                  ^^^^
+//│ ╟── but it flows into application with expected type `int`
+//│ ║  l.31: 	succ / foo(1)
+//│ ╙──      	       ^^^^^^
+//│ res: error | int
+//│ res: bool | int
+//│ ╔══[ERROR] Type mismatch in application:
+//│ ║  l.33: 	not / foo(true)
+//│ ║        	^^^^^^^^^^^^^^^
+//│ ╟── reference of type `int` is not an instance of type `bool`
+//│ ║  l.26: 	let foo = (Int => Int) & (Bool => Bool)
+//│ ║        	                  ^^^
+//│ ╟── but it flows into application with expected type `bool`
+//│ ║  l.33: 	not / foo(true)
+//│ ╙──      	      ^^^^^^^^^
+//│ res: bool | error
 
 :e
 not / foo(1)
 foo(1) as Nothing
 //│ ╔══[ERROR] Type mismatch in application:
-//│ ║  l.42: 	not / foo(1)
+//│ ║  l.58: 	not / foo(1)
 //│ ║        	^^^^^^^^^^^^
 //│ ╟── reference of type `int` is not an instance of type `bool`
 //│ ║  l.26: 	let foo = (Int => Int) & (Bool => Bool)
 //│ ║        	                  ^^^
 //│ ╟── but it flows into application with expected type `bool`
-//│ ║  l.42: 	not / foo(1)
+//│ ║  l.58: 	not / foo(1)
 //│ ╙──      	      ^^^^^^
 //│ res: bool | error
 //│ ╔══[ERROR] Type mismatch in 'as' binding:
-//│ ║  l.43: 	foo(1) as Nothing
+//│ ║  l.59: 	foo(1) as Nothing
 //│ ║        	^^^^^^^^^^^^^^^^^
 //│ ╟── reference of type `int` does not match type `nothing`
 //│ ║  l.26: 	let foo = (Int => Int) & (Bool => Bool)
 //│ ║        	                  ^^^
 //│ ╟── but it flows into application with expected type `nothing`
-//│ ║  l.43: 	foo(1) as Nothing
+//│ ║  l.59: 	foo(1) as Nothing
 //│ ║        	^^^^^^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.43: 	foo(1) as Nothing
+//│ ║  l.59: 	foo(1) as Nothing
 //│ ╙──      	          ^^^^^^^
 //│ res: nothing
 
 :e
 foo as Nothing
 //│ ╔══[ERROR] Type mismatch in 'as' binding:
-//│ ║  l.69: 	foo as Nothing
+//│ ║  l.85: 	foo as Nothing
 //│ ║        	^^^^^^^^^^^^^^
 //│ ╟── type intersection of type `int -> int & bool -> bool` does not match type `nothing`
 //│ ║  l.26: 	let foo = (Int => Int) & (Bool => Bool)
 //│ ║        	          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 //│ ╟── but it flows into reference with expected type `nothing`
-//│ ║  l.69: 	foo as Nothing
+//│ ║  l.85: 	foo as Nothing
 //│ ║        	^^^
 //│ ╟── Note: constraint arises from reference:
-//│ ║  l.69: 	foo as Nothing
+//│ ║  l.85: 	foo as Nothing
 //│ ╙──      	       ^^^^^^^
 //│ res: nothing
 
 :e
 let oops = (&)
 //│ ╔══[ERROR] Illegal use of reserved operator: &
-//│ ║  l.85: 	let oops = (&)
-//│ ╙──      	           ^^^
+//│ ║  l.101: 	let oops = (&)
+//│ ╙──       	           ^^^
 //│ ╔══[ERROR] identifier not found: &
-//│ ║  l.85: 	let oops = (&)
-//│ ╙──      	           ^^^
+//│ ║  l.101: 	let oops = (&)
+//│ ╙──       	           ^^^
 //│ oops: error
 

shared/src/test/diff/fcp/Overloads.mls

@@ -1,6 +1,6 @@
 
 :NoJS
-
+:NoApproximateOverload
 
 type IISS = int -> int & string -> string
 type BBNN = bool -> bool & number -> number

shared/src/test/diff/mlscript/BadPolym.mls

@@ -40,11 +40,11 @@ fooImpl id
 
 
 fooImpl2 (f: int -> int & string -> string) = f 1
-//│ fooImpl2: (int -> int & string -> string) -> int
+//│ fooImpl2: (int -> int & string -> string) -> (int | string)
 //│         = [Function: fooImpl2]
 
 fooImpl2 id
-//│ res: int
+//│ res: int | string
 //│    = 1
 
 :e

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

@@ -155,7 +155,7 @@ module A {
 //│ }
 
 A.g(0)
-//│ Int
+//│ Int | Str
 //│ res
 //│     = 0
 
@@ -174,13 +174,13 @@ s([Numbr(0),Numbr(0)])
 //│ ╔══[ERROR] Type mismatch in application:
 //│ ║  l.+1: 	s([Numbr(0),Numbr(0)])
 //│ ║        	^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── type `(Numbr | Vectr, Numbr | Vectr) -> Int` is not a function
-//│ ║  l.136: 	fun s: ([Numbr,Numbr] -> Int) & ([Vectr,Vectr] -> Int)
-//│ ║         	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//│ ╟── but it flows into reference with expected type `([?a, ?b]) -> ?c`
+//│ ╟── argument of type `[[?a, ?b]]` does not match type `[Numbr | Vectr, Numbr | Vectr]`
 //│ ║  l.+1: 	s([Numbr(0),Numbr(0)])
-//│ ╙──      	^
-//│ error
+//│ ║        	 ^^^^^^^^^^^^^^^^^^^^^
+//│ ╟── Note: constraint arises from tuple type:
+//│ ║  l.136: 	fun s: ([Numbr,Numbr] -> Int) & ([Vectr,Vectr] -> Int)
+//│ ╙──       	        ^^^^^^^^^^^^^
+//│ Int | error
 // g <: 0 -> 'a
 
 :e