Cache substitutions (#954)

Substitutions are used multiple times but computed over and over again.
This PR caches them until any modification happens.

On my machine, this brings down typer from `1150ms` to `720ms` with 

```
effekt --time text examples/casestudies/anf.effekt.md
```

This shaves of 25% of the total compile time, which is reduced from 2.5s
to 2s.

Author: b-studios

effekt/shared/src/main/scala/effekt/typer/Constraints.scala

@@ -121,16 +121,25 @@ class Constraints(
    * Unification variables which are not in scope anymore, but also haven't been solved, yet.
    */
   private var pendingInactive: Set[CNode] = Set.empty
-
 )(using C: ErrorReporter) {
 
+  /**
+   * Caches type substitutions, which are only invalidated if the mapping from node to typevar changes.
+   *
+   * This significantly improves the performance of Typer (see https://github.com/effekt-lang/effekt/pull/954)
+   */
+  private var _typeSubstitution:  Map[TypeVar, ValueType] = _
+  private def invalidate(): Unit = _typeSubstitution = null
+
   /**
    * The currently known substitutions
    */
   def subst: Substitutions =
-    val types = classes.flatMap[TypeVar, ValueType] { case (k, v) => typeSubstitution.get(v).map { k -> _ } }
+    if _typeSubstitution == null then {
+      _typeSubstitution = classes.flatMap[TypeVar, ValueType] { case (k, v) => typeSubstitution.get(v).map { k -> _ } }
+    }
     val captures = captSubstitution.asInstanceOf[Map[CaptVar, Captures]]
-    Substitutions(types, captures)
+    Substitutions(_typeSubstitution, captures)
 
   /**
    * Should only be called on unification variables where we do not know any types, yet
@@ -308,16 +317,18 @@ class Constraints(
     private [typer] def upperNodes: Map[CNode, Filter] = getData(x).upperNodes
     private def lower_=(bounds: Set[Capture]): Unit =
       captureConstraints = captureConstraints.updated(x, getData(x).copy(lower = Some(bounds)))
+
     private def upper_=(bounds: Set[Capture]): Unit =
       captureConstraints = captureConstraints.updated(x, getData(x).copy(upper = Some(bounds)))
+
     private def addLower(other: CNode, exclude: Filter): Unit =
       val oldData = getData(x)
 
       // compute the intersection of filters
       val oldFilter = oldData.lowerNodes.get(other)
       val newFilter = oldFilter.map { _ intersect exclude }.getOrElse { exclude }
-
       captureConstraints = captureConstraints.updated(x, oldData.copy(lowerNodes = oldData.lowerNodes + (other -> newFilter)))
+
     private def addUpper(other: CNode, exclude: Filter): Unit =
       val oldData = getData(x)
 
@@ -462,6 +473,7 @@ class Constraints(
    */
   private def updateSubstitution(): Unit =
     val substitution = subst
+    invalidate()
     typeSubstitution = typeSubstitution.map { case (node, tpe) => node -> substitution.substitute(tpe) }
 
   private def getNode(x: UnificationVar): Node =

effekt/shared/src/main/scala/effekt/typer/Substitution.scala

@@ -31,12 +31,6 @@ case class Substitutions(
   }
   def get(x: CaptUnificationVar): Option[Captures] = captures.get(x)
 
-  // amounts to first substituting this, then other
-  def updateWith(other: Substitutions): Substitutions =
-    Substitutions(
-      values.view.mapValues { t => other.substitute(t) }.toMap,
-      captures.view.mapValues { t => other.substitute(t) }.toMap) ++ other
-
   // amounts to parallel substitution
   def ++(other: Substitutions): Substitutions = Substitutions(values ++ other.values, captures ++ other.captures)
 
@@ -95,4 +89,4 @@ object Substitutions {
   def apply(values: List[(TypeVar, ValueType)], captures: List[(CaptVar, Captures)]): Substitutions = Substitutions(values.toMap, captures.toMap)
   def types(keys: List[TypeVar], values: List[ValueType]): Substitutions = Substitutions((keys zip values).toMap, Map.empty)
   def captures(keys: List[CaptVar], values: List[Captures]): Substitutions = Substitutions(Map.empty, (keys zip values).toMap)
-}
+}