resolve: save dependencies in GeneralizedVar; print cycle

base/src/main/java/org/aya/resolve/error/CyclicDependencyError.java

@@ -8,17 +8,21 @@
 import org.aya.syntax.ref.GeneralizedVar;
 import org.aya.util.error.SourcePos;
 import org.jetbrains.annotations.NotNull;
+import kala.collection.immutable.ImmutableSeq;
 
 public record CyclicDependencyError(
   @NotNull SourcePos sourcePos,
-  @NotNull GeneralizedVar var
+  @NotNull GeneralizedVar var,
+  @NotNull ImmutableSeq<GeneralizedVar> cyclePath
 ) implements Problem {
   @Override public @NotNull Severity level() { return Severity.ERROR; }
   @Override public @NotNull Stage stage() { return Stage.RESOLVE; }
   @Override public @NotNull Doc describe(@NotNull PrettierOptions options) {
-    return Doc.sep(
-      Doc.plain("Cyclic dependency detected in variable declaration:"),
-      Doc.plain(var.name())
+    return Doc.vcat(
+      Doc.plain("Cyclic dependency detected in variable declarations:"),
+      Doc.plain(String.join(" -> ", cyclePath.view()
+        .map(GeneralizedVar::name)
+        .toImmutableSeq()))
     );
   }
 }

base/src/main/java/org/aya/resolve/visitor/VariableDependencyCollector.java

@@ -34,10 +34,10 @@
  *     if it’s not in the allowedGeneralizes map.
  */
 public final class VariableDependencyCollector {
-  private final Map<GeneralizedVar, ImmutableSeq<GeneralizedVar>> dependencies = new HashMap<>();
   private final Reporter reporter;
   private final MutableSet<GeneralizedVar> visiting = MutableSet.create();
   private final MutableSet<GeneralizedVar> visited = MutableSet.create();
+  private final MutableList<GeneralizedVar> currentPath = MutableList.create();
 
   public VariableDependencyCollector(Reporter reporter) {
     this.reporter = reporter;
@@ -46,26 +46,29 @@ public VariableDependencyCollector(Reporter reporter) {
   public void registerVariable(GeneralizedVar var) {
     if (visited.contains(var)) return;
 
-    // If var is already being visited in current DFS path, we found a cycle
     if (!visiting.add(var)) {
-      reporter.report(new CyclicDependencyError(var.sourcePos(), var));
+      // Find cycle start index
+      var cycleStart = currentPath.indexOf(var);
+      var cyclePath = currentPath.view().drop(cycleStart).appended(var);
+      reporter.report(new CyclicDependencyError(var.sourcePos(), var, cyclePath.toImmutableSeq()));
       throw new Context.ResolvingInterruptedException();
     }
 
+    currentPath.append(var);
     var deps = collectReferences(var);
-    dependencies.put(var, deps);
+    var.setDependencies(deps);
 
-    // Recursively register dependencies
     for (var dep : deps) {
       registerVariable(dep);
     }
 
+    currentPath.removeLast();
     visiting.remove(var);
     visited.add(var);
   }
 
   public ImmutableSeq<GeneralizedVar> getDependencies(GeneralizedVar var) {
-    return dependencies.getOrDefault(var, ImmutableSeq.empty());
+    return var.getDependencies();
   }
 
   private ImmutableSeq<GeneralizedVar> collectReferences(GeneralizedVar var) {

cli-impl/src/test/java/org/aya/test/fixtures/ScopeError.java

@@ -103,4 +103,8 @@ def test (A : Type) (a : A) : A =>
           | x : A := a
       in x
     """;
+  @Language("Aya") String testCyclicDependency = """
+    variable A : B
+    variable B : A
+  """;
 }

cli-impl/src/test/resources/negative/ScopeError.txt

@@ -318,3 +318,6 @@ That looks right!
 LocalShadowSuppress:
 That looks right!
 
+CyclicDependency:
+That looks right!
+

syntax/src/main/java/org/aya/syntax/ref/GeneralizedVar.java

@@ -6,17 +6,27 @@
 import org.aya.util.error.SourceNode;
 import org.aya.util.error.SourcePos;
 import org.jetbrains.annotations.NotNull;
+import kala.collection.immutable.ImmutableSeq;
 
 public final class GeneralizedVar implements AnyVar, SourceNode {
   public final @NotNull String name;
   public final @NotNull SourcePos sourcePos;
   public Generalize owner;
+  private @NotNull ImmutableSeq<GeneralizedVar> dependencies = ImmutableSeq.empty();
 
   public GeneralizedVar(@NotNull String name, @NotNull SourcePos sourcePos) {
     this.name = name;
     this.sourcePos = sourcePos;
   }
 
+  public void setDependencies(@NotNull ImmutableSeq<GeneralizedVar> deps) {
+    this.dependencies = deps;
+  }
+
+  public @NotNull ImmutableSeq<GeneralizedVar> getDependencies() {
+    return dependencies;
+  }
+
   public @NotNull LocalVar toLocal() {
     return new LocalVar(name, sourcePos, new GenerateKind.Generalized(this));
   }