Detect cycles in PolyConstraints

Author: mattisboeckle

effekt/shared/src/main/scala/effekt/core/Mono.scala

@@ -5,8 +5,6 @@ import effekt.context.Context
 import effekt.lexer.TokenKind
 import effekt.context.assertions.asDataType
 
-// import scala.collection.mutable
-
 object Mono extends Phase[CoreTransformed, CoreTransformed] {
 
   override val phaseName: String = "mono"
@@ -27,31 +25,32 @@ object Mono extends Phase[CoreTransformed, CoreTransformed] {
   }
 }
 
-// TODO: We probably want some kind of graph data structure instead of the map, for better performance in cycle detection later.
-//       This works for now
-// TODO: Consider using unique IDs instead of Symbol for keys.
-//       This works, but might give weird output when debugging
-//       if the same symbol name is used twice
 // TODO: After solving the constraints it would be helpful to know
 //       which functions have which tparams
 //       so we can generate the required monomorphic functions
-type PolyConstraint = Map[symbols.Symbol, Set[symbols.Symbol]]
-type PolyConstraintEntry = (symbols.Symbol, Set[symbols.Symbol])
 
-def appendConstraint(map: PolyConstraint, sym: symbols.Symbol, tpe: ValueType): PolyConstraintEntry =
+enum PolyType {
+  case Var(val sym: symbols.Symbol)
+  case Base(val tpe: symbols.Symbol)
+}
+
+type PolyConstraints = Map[symbols.Symbol, Set[PolyType]]
+type PolyConstraintEntry = (symbols.Symbol, Set[PolyType])
+
+def appendConstraint(map: PolyConstraints, sym: symbols.Symbol, tpe: ValueType): PolyConstraintEntry =
   val currentFlow = map.getOrElse(sym, Set())
   tpe match {
     // Ignore self cycling types A -> A
-    case ValueType.Data(name, targs) if name != sym => (sym -> currentFlow.incl(name))
-    case ValueType.Var(name) if name != sym => (sym -> (currentFlow.incl(name))) 
+    case ValueType.Data(name, targs) if name != sym => (sym -> (currentFlow + PolyType.Base(name)))
+    case ValueType.Var(name) if name != sym => (sym -> (currentFlow + PolyType.Var(name)))
     // TODO: What do we do with boxed types?
     case o@ValueType.Boxed(tpe, capt) => 
       println("Hit boxed type: " + o)
       (sym -> currentFlow)
     case _ => (sym -> currentFlow) // self cycling flow
   }
 
-def findConstraintRec(value: Val, typeFlow: PolyConstraint): PolyConstraint =
+def findConstraintRec(value: Val, typeFlow: PolyConstraints): PolyConstraints =
   var newTypeFlow = typeFlow
   value.binding match {
     case App(callee, targ :: targs, vargs, bargs) =>
@@ -71,8 +70,8 @@ def findConstraintRec(value: Val, typeFlow: PolyConstraint): PolyConstraint =
     case _ => newTypeFlow
   }
 
-def findConstraints(definitions: List[Toplevel]): PolyConstraint =
-  var typeFlow: PolyConstraint = Map()
+def findConstraints(definitions: List[Toplevel]): PolyConstraints =
+  var typeFlow: PolyConstraints = Map()
   definitions.foreach {
     case Toplevel.Def(id, block) =>
       block match
@@ -93,4 +92,31 @@ def findConstraints(definitions: List[Toplevel]): PolyConstraint =
         case _ => 
     case _ =>
   }
-  typeFlow
+  typeFlow
+
+object PolyGraphCalc {
+  var visited: Set[symbols.Symbol] = Set()
+  var recStack: Set[symbols.Symbol] = Set()
+
+  def hasCycle(vertex: symbols.Symbol, adjacency: PolyConstraints): Boolean =  
+    if (recStack.contains(vertex)) return true
+
+    if (visited.contains(vertex)) return false
+
+    visited += vertex
+    recStack += vertex
+
+    adjacency.foreach((v, edges) => if (hasCycle(v, adjacency)) return true)
+
+    recStack -= vertex
+    false
+
+  def hasCycle(constraints: PolyConstraints): Boolean =
+    visited = Set()
+    recStack = Set()
+
+    constraints.keys.foreach(v => if (hasCycle(v, constraints)) return true)
+
+    false
+}
+