Support for GADTs

compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala

@@ -741,7 +741,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     val nTerms = termList.map(liftTerm(_)(using emptyCtx, nCache, globFuncs, nOuter)).unzip
     clsList.foreach(x => liftTypeDef(x)(using nCache, globFuncs, nOuter))
     retSeq = retSeq.appended(NuTypeDef(
-      kind, nName, nTps.map((None, _)), S(Tup(nParams)), None, None, nPars._1,
+      kind, nName, nTps.map((TypeParamInfo(None, false, N, N), _)), S(Tup(nParams)), None, None, nPars._1,
       None, None, TypingUnit(nFuncs._1 ++ nTerms._1))(None, None))
   }
 

shared/src/main/scala/mlscript/NewLexer.scala

@@ -408,7 +408,7 @@ object NewLexer {
     "val",
     "var",
     // "is",
-    // "as",
+    "as",
     "of",
     // "and",
     // "or",
@@ -442,7 +442,8 @@ object NewLexer {
     "undefined",
     "abstract",
     "constructor",
-    "virtual"
+    "virtual",
+    "restricts",
   )
 
   def printToken(tl: TokLoc): Str = tl match {

shared/src/main/scala/mlscript/NewParser.scala

@@ -646,6 +646,9 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
       case (KEYWORD("super"), l0) :: _ =>
         consume
         exprCont(Super().withLoc(S(l0)), prec, allowNewlines = false)
+      case (IDENT("?", true), l0) :: _ => 
+        consume
+        exprCont(Var("?").withLoc(S(l0)), prec, allowNewlines = false)
       case (IDENT("~", _), l0) :: _ =>
         consume
         val rest = expr(prec, allowSpace = true)
@@ -910,7 +913,7 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
                 else App(App(v, PlainTup(acc)), PlainTup(rhs))
             }, prec, allowNewlines)
         }
-      case (KEYWORD(":"), l0) :: _ if prec <= NewParser.prec(':') =>
+      case (KEYWORD("as" | ":"), l0) :: _ if prec <= NewParser.prec(':') =>
         consume
         R(Asc(acc, typ(0)))
       case (KEYWORD("where"), l0) :: _ if prec <= 1 =>
@@ -1108,35 +1111,59 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
     }
 
   // TODO support line-broken param lists; share logic with args/argsOrIf
-  def typeParams(implicit fe: FoundErr, et: ExpectThen): Ls[(Opt[VarianceInfo], TypeName)] = {
+  def typeParams(implicit fe: FoundErr, et: ExpectThen): Ls[(TypeParamInfo, TypeName)] = {
+    val visinfo = yeetSpaces match {
+      case (KEYWORD("type"), l0) :: _ =>
+        consume
+        S(l0)
+      case _ => N
+    }
     val vinfo = yeetSpaces match {
       case (KEYWORD("in"), l0) :: (KEYWORD("out"), l1) :: _ =>
         consume
-        S(VarianceInfo.in, l0 ++ l1)
+        S(VarianceInfo.in -> (l0++l1))
       case (KEYWORD("in"), l0) :: _ =>
         consume
-        S(VarianceInfo.contra, l0)
+        S(VarianceInfo.contra -> l0)
       case (KEYWORD("out"), l0) :: _ =>
         consume
-        S(VarianceInfo.co, l0)
-      case _ => N
+        S(VarianceInfo.co -> l0)
+      case _ =>
+        N
     }
     yeetSpaces match {
       case (IDENT(nme, false), l0) :: _ =>
         consume
         val tyNme = TypeName(nme).withLoc(S(l0))
+
+        @inline def getTypeName(kw: String) = yeetSpaces match {
+          case (KEYWORD(k), l0) :: _ if k === kw => consume
+            yeetSpaces match {
+              case (IDENT(nme, false), l1) :: _ => 
+                consume; S(TypeName(nme).withLoc(S(l1)))
+              case _ => err(msg"dangling $kw keyword" -> S(l0) :: Nil); N
+            }
+          case _ => N
+        }
+        val lb = getTypeName("restricts")
+        val ub = getTypeName("extends")
+        // TODO update `TypeParamInfo` to use lb and ub
         yeetSpaces match {
           case (COMMA, l0) :: _ =>
             consume
-            vinfo.map(_._1) -> tyNme :: typeParams
+            TypeParamInfo(vinfo.map(_._1), visinfo.isDefined, lb, ub) -> tyNme :: typeParams
           case _ =>
-            vinfo.map(_._1) -> tyNme :: Nil
+            TypeParamInfo(vinfo.map(_._1), visinfo.isDefined, lb, ub) -> tyNme :: Nil
         }
       case _ =>
-        vinfo match {
-          case S((_, loc)) =>
+        (visinfo, vinfo) match {
+          case (S(l1), S(_ -> l2)) =>
+            err(msg"dangling type member and variance information" -> S(l1 ++ l2) :: Nil)
+          case (_, S(_ -> loc)) =>
             err(msg"dangling variance information" -> S(loc) :: Nil)
-          case N =>
+          case (S(loc), _) =>
+            err(msg"dangling visible type member" -> S(loc) :: Nil)
+          case (N, N) =>
         }
         Nil
     }
@@ -1203,7 +1230,7 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], newDefs: Bo
       case (NEWLINE, _) :: _ => // TODO: | ...
         assert(seqAcc.isEmpty)
         acc.reverse
-      case (IDENT(nme, true), _) :: _ if nme =/= "-" => // TODO: | ...
+      case (IDENT(nme, true), _) :: _ if nme =/= "-" && nme =/= "?" => // TODO: | ...
         assert(seqAcc.isEmpty)
         acc.reverse
       case _ =>

shared/src/main/scala/mlscript/NormalForms.scala

@@ -22,9 +22,13 @@ class NormalForms extends TyperDatatypes { self: Typer =>
     mergeSortedMap(trs1, trs2) { (tr1, tr2) =>
       assert(tr1.defn === tr2.defn)
       assert(tr1.targs.size === tr2.targs.size)
-      TypeRef(tr1.defn, (tr1.targs lazyZip tr2.targs).map((ta1, ta2) => 
-          if (pol) TypeBounds.mk(ta1 & ta2, ta1 | ta2) else TypeBounds.mk(ta1 | ta2, ta1 & ta2)
-        ))(noProv)
+      TypeRef(tr1.defn, (tr1.targs lazyZip tr2.targs).map {
+        case (l: WildcardArg, r: WildcardArg) => 
+          if (pol) WildcardArg.mk(l.lb | r.lb, l.ub & r.ub) else WildcardArg.mk(l.lb & r.lb, l.ub | r.ub)
+        case (l: WildcardArg, r: ST) => if (pol) WildcardArg.mk(l.lb | r, l.ub & r) else WildcardArg.mk(l.lb & r, l.ub | r)
+        case (l: ST, r: WildcardArg) => if (pol) WildcardArg.mk(l | r.lb, l & r.ub) else WildcardArg.mk(l & r.lb, l | r.ub)
+        case (l: ST, r: ST) => if (pol) WildcardArg.mk(l | r, l & r) else WildcardArg.mk(l & r, l | r)
+      })(noProv)
     }
 
 
@@ -196,11 +200,25 @@ class NormalForms extends TyperDatatypes { self: Typer =>
             val thatTarg = thatTargs.head
             thatTargs = thatTargs.tail
             vce match {
-              case S(true) => otherTarg & thatTarg
-              case S(false) => otherTarg | thatTarg
-              case N =>
-                if (pol) TypeBounds.mk(otherTarg | thatTarg, otherTarg & thatTarg)
-                else TypeBounds.mk(otherTarg & thatTarg, otherTarg | thatTarg)
+              case S(true) => (otherTarg, thatTarg) match {
+                case (l: WildcardArg, r: WildcardArg) => WildcardArg.mk(l.lb | r.lb, l.ub & r.ub)
+                case (l: WildcardArg, r: ST) => l.ub & r
+                case (l: ST, r: WildcardArg) => l & r.ub
+                case (l: ST, r: ST) => l & r
+              }
+              case S(false) => (otherTarg, thatTarg) match {
+                case (l: WildcardArg, r: WildcardArg) => WildcardArg.mk(l.lb & r.lb, l.ub | r.ub)
+                case (l: WildcardArg, r: ST) => l.lb | r
+                case (l: ST, r: WildcardArg) => l | r.lb
+                case (l: ST, r: ST) => l | r
+              }
+              case N => (otherTarg, thatTarg) match {
+                case (l: WildcardArg, r: WildcardArg) => 
+                  if (pol) WildcardArg.mk(l.lb | r.lb, l.ub & r.ub) else WildcardArg.mk(l.lb & r.lb, l.ub | r.ub)
+                case (l: WildcardArg, r: ST) => if (pol) WildcardArg.mk(l.lb | r, l.ub & r) else WildcardArg.mk(l.lb & r, l.ub | r)
+                case (l: ST, r: WildcardArg) => if (pol) WildcardArg.mk(l | r.lb, l & r.ub) else WildcardArg.mk(l & r.lb, l | r.ub)
+                case (l: ST, r: ST) => if (pol) WildcardArg.mk(l | r, l & r) else WildcardArg.mk(l & r, l | r)
+              } 
             }
           }
           TypeRef(that.defn, newTargs)(that.prov)
@@ -241,7 +259,14 @@ class NormalForms extends TyperDatatypes { self: Typer =>
       case (LhsTop, _) => false
       case (LhsRefined(b1, ts1, rt1, trs1), LhsRefined(b2, ts2, rt2, trs2)) =>
         b2.forall(b2 => b1.exists(_ <:< b2)) &&
-          ts2.forall(ts1) && rt1 <:< rt2 &&
+          ts2.forall {
+            case sk: SkolemTag => ts1(sk)
+            case tt: TraitTag => ts1(tt)
+            case Extruded(pol, sk) => !pol || ts1.exists { // find ? <: bot
+              case Extruded(true, _) => true
+              case _ => false
+            }
+          } && rt1 <:< rt2 &&
           trs2.valuesIterator.forall(tr2 => trs1.valuesIterator.exists(_ <:< tr2))
     }
     def isTop: Bool = isInstanceOf[LhsTop.type]
@@ -294,11 +319,25 @@ class NormalForms extends TyperDatatypes { self: Typer =>
             val thatTarg = thatTargs.head
             thatTargs = thatTargs.tail
             vce match {
-              case S(true) => otherTarg | thatTarg
-              case S(false) => otherTarg & thatTarg
-              case N =>
-                if (pol) TypeBounds.mk(otherTarg & thatTarg, otherTarg | thatTarg)
-                else TypeBounds.mk(otherTarg | thatTarg, otherTarg & thatTarg)
+              case S(true) => (otherTarg, thatTarg) match {
+                case (l: WildcardArg, r: WildcardArg) => WildcardArg.mk(l.lb & r.lb, l.ub | r.ub)
+                case (l: WildcardArg, r: ST) => l.lb | r
+                case (l: ST, r: WildcardArg) => l | r.lb
+                case (l: ST, r: ST) => l | r
+              }
+              case S(false) => (otherTarg, thatTarg) match {
+                case (l: WildcardArg, r: WildcardArg) => WildcardArg.mk(l.lb | r.lb, l.ub & r.ub)
+                case (l: WildcardArg, r: ST) => l.ub & r
+                case (l: ST, r: WildcardArg) => l & r.ub
+                case (l: ST, r: ST) => l & r
+              }
+              case N => (otherTarg, thatTarg) match {
+                case (l: WildcardArg, r: WildcardArg) => 
+                  if (pol)  WildcardArg.mk(l.lb & r.lb, l.ub | r.ub) else WildcardArg.mk(l.lb | r.lb, l.ub & r.ub) 
+                case (l: WildcardArg, r: ST) => if (pol)  WildcardArg.mk(l.lb & r, l.ub | r) else WildcardArg.mk(l.lb | r, l.ub & r)
+                case (l: ST, r: WildcardArg) => if (pol)  WildcardArg.mk(l & r.lb, l | r.ub) else WildcardArg.mk(l | r.lb, l & r.ub) 
+                case (l: ST, r: ST) => if (pol) WildcardArg.mk(l & r, l | r) else WildcardArg.mk(l | r, l & r)
+              }
             }
           }
           TypeRef(that.defn, newTargs)(that.prov)
@@ -760,7 +799,7 @@ class NormalForms extends TyperDatatypes { self: Typer =>
         // * TODO later: when proper TypeRef-based simplif. is implemented, can remove this special case
         if (preserveTypeRefs && !primitiveTypes.contains(defn.name) || !tr.canExpand) {
           of(polymLvl, cons, LhsRefined(tr.mkClsTag, ssEmp, RecordType.empty, SortedMap(defn -> tr)))
-        } else mk(polymLvl, cons, tr.expandOrCrash, pol)
+        } else mk(polymLvl, cons, tr.expandOrCrash(pol), pol)
       case TypeBounds(lb, ub) => mk(polymLvl, cons, if (pol) ub else lb, pol)
       case PolymorphicType(lvl, bod) => mk(lvl, cons, bod, pol)
       case ConstrainedType(cs, bod) => mk(polymLvl, cs ::: cons, bod, pol)
@@ -804,7 +843,7 @@ class NormalForms extends TyperDatatypes { self: Typer =>
         case tr @ TypeRef(defn, targs) =>
           if (preserveTypeRefs && !primitiveTypes.contains(defn.name) || !tr.canExpand) {
             CNF(Disjunct(RhsBases(Nil, N, SortedMap.single(defn -> tr)), ssEmp, LhsTop, ssEmp) :: Nil)
-          } else mk(polymLvl, cons, tr.expandOrCrash, pol)
+          } else mk(polymLvl, cons, tr.expandOrCrash(pol), pol)
         case TypeBounds(lb, ub) => mk(polymLvl, cons, if (pol) ub else lb, pol)
         case PolymorphicType(lvl, bod) => mk(lvl, cons, bod, pol)
         case ConstrainedType(cs, bod) => mk(lvl, cs ::: cons, bod, pol)