Properly distinguish free variables and dependencies

1 files changed, 16 insertions, 17 deletions

diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
index fe844d66..f4c0af7f 100644
--- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
+++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
@@ -589,7 +589,7 @@ public class TypeChecker {
             context = typeCheckSteps.declareFunctions(context);
         }
 
-        var dependencies = new ArrayList<Set<String>>();
+        var dependenciesByBodyStatementIndex = new ArrayList<Set<FreeVariable>>();
         var variableNames = untyped.body().stream()
             .flatMap(untypedStatement -> declaredVariables(untypedStatement, P.vector()).stream())
             .map(declaration -> declaration.name())
@@ -608,19 +608,18 @@ public class TypeChecker {
 
             typedBody.add(typedStatement);
 
-            var freeVariableNames = freeVariables.stream()
+            var dependencies = freeVariables.stream()
                 .filter(freeVariable -> variableNames.contains(freeVariable.name()))
-                .map(freeVariable -> freeVariable.name())
                 .collect(Collectors.toSet());
-            dependencies.add(freeVariableNames);
+            dependenciesByBodyStatementIndex.add(dependencies);
         }
 
-        var deferredDependencies = new HashMap<String, Set<String>>();
+        var deferredDependenciesByFunctionName = new HashMap<String, Set<FreeVariable>>();
         for (var i = 0; i < untyped.body().size(); i++) {
             var untypedStatement = untyped.body().get(i);
             if (untypedStatement instanceof UntypedFunctionDefinitionNode functionDefinition) {
-                var freeVariables = dependencies.get(i);
-                deferredDependencies.put(functionDefinition.name(), freeVariables);
+                var dependencies = dependenciesByBodyStatementIndex.get(i);
+                deferredDependenciesByFunctionName.put(functionDefinition.name(), dependencies);
             }
         }
 
@@ -631,34 +630,34 @@ public class TypeChecker {
                 defined.add(name);
             }
 
-            void require(String name) {
-                if (defined.contains(name)) {
+            void require(FreeVariable dependency) {
+                if (defined.contains(dependency.name())) {
                     return;
                 }
 
-                var freeVariables = deferredDependencies.get(name);
+                var subdependencies = deferredDependenciesByFunctionName.get(dependency.name());
 
-                if (freeVariables == null) {
+                if (subdependencies == null) {
                     // TODO: fix source
-                    throw new ReferenceBeforeDefinitionError(name, Sources.NULL);
+                    throw new ReferenceBeforeDefinitionError(dependency.name(), Sources.NULL);
                 }
 
-                for (var dependency : freeVariables) {
-                    require(dependency);
+                for (var subdependency : subdependencies) {
+                    require(subdependency);
                 }
             }
         };
 
         for (var i = 0; i < untyped.body().size(); i++) {
             var untypedStatement = untyped.body().get(i);
-            var freeVariables = dependencies.get(i);
+            var dependencies = dependenciesByBodyStatementIndex.get(i);
 
             switch (untypedStatement) {
                 case UntypedFunctionDefinitionNode functionDefinition -> {
                 }
                 case UntypedValNode val -> {
-                    for (var freeVariable : freeVariables) {
-                        state.require(freeVariable);
+                    for (var dependency : dependencies) {
+                        state.require(dependency);
                     }
 
                     for (var declaredVariable : declaredVariables(val, P.vector())) {