Wip

src/main/java/net/hydromatic/morel/compile/Compiles.java

@@ -91,7 +91,7 @@ private static CompiledStatement prepareDecl(TypeSystem typeSystem,
     final boolean relationalize =
         Prop.RELATIONALIZE.booleanValue(session.map);
 
-    final Resolver resolver = Resolver.of(resolved.typeMap, env);
+    final Resolver resolver = Resolver.of(resolved.typeMap, env, session);
     final Core.Decl coreDecl0 = resolver.toCore(resolved.node);
     tracer.onCore(0, coreDecl0);
 

src/main/java/net/hydromatic/morel/compile/Inliner.java

@@ -102,6 +102,10 @@ public static Inliner of(TypeSystem typeSystem, Environment env,
         default:
           if (v instanceof Code) {
             v = ((Code) v).eval(Compiler.EMPTY_ENV);
+            if (v == null) {
+              // Cannot inline SYS_FILE; it requires a session.
+              break;
+            }
           }
           return core.valueLiteral(id, v);
         }

src/main/java/net/hydromatic/morel/compile/Resolver.java

@@ -26,6 +26,7 @@
 import net.hydromatic.morel.ast.Shuttle;
 import net.hydromatic.morel.ast.Visitor;
 import net.hydromatic.morel.eval.Codes;
+import net.hydromatic.morel.eval.Session;
 import net.hydromatic.morel.type.Binding;
 import net.hydromatic.morel.type.DataType;
 import net.hydromatic.morel.type.FnType;
@@ -44,6 +45,7 @@
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedMap;
 import org.apache.calcite.util.Util;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
 import java.util.ArrayDeque;
@@ -84,6 +86,7 @@ public class Resolver {
   final TypeMap typeMap;
   private final NameGenerator nameGenerator;
   private final Environment env;
+  private final @Nullable Session session;
 
   /** Contains variable declarations whose type at the point they are used is
    * different (more specific) than in their declaration.
@@ -101,22 +104,25 @@ public class Resolver {
 
   private Resolver(TypeMap typeMap, NameGenerator nameGenerator,
       Map<Pair<Core.NamedPat, Type>, Core.NamedPat> variantIdMap,
-      Environment env) {
+      Environment env, @Nullable Session session) {
     this.typeMap = typeMap;
     this.nameGenerator = nameGenerator;
     this.variantIdMap = variantIdMap;
     this.env = env;
+    this.session = session;
   }
 
   /** Creates a root Resolver. */
-  public static Resolver of(TypeMap typeMap, Environment env) {
-    return new Resolver(typeMap, new NameGenerator(), new HashMap<>(), env);
+  public static Resolver of(TypeMap typeMap, Environment env,
+      @Nullable Session session) {
+    return new Resolver(typeMap, new NameGenerator(), new HashMap<>(), env,
+        session);
   }
 
   /** Binds a Resolver to a new environment. */
   public Resolver withEnv(Environment env) {
     return env == this.env ? this
-        : new Resolver(typeMap, nameGenerator, variantIdMap, env);
+        : new Resolver(typeMap, nameGenerator, variantIdMap, env, session);
   }
 
   /** Binds a Resolver to an environment that consists of the current
@@ -485,6 +491,14 @@ Object valueOf(Core.Exp exp) {
       final Core.Id id = (Core.Id) exp;
       Binding binding = env.getOpt(id.idPat);
       if (binding != null) {
+        if (binding.value == Codes.SYS_FILE) {
+          // We can't evaluate, because we don't have an EvalEnv. But we
+          // can go straight to the Session.
+          if (session == null) {
+            return null;
+          }
+          return session.file.get();
+        }
         return binding.value;
       }
     }

src/main/java/net/hydromatic/morel/eval/Codes.java

@@ -2324,8 +2324,29 @@ private static Core.Exp sysEnv(TypeSystem typeSystem, Environment env,
         core.tuple(typeSystem, null, args));
   }
 
-  /** @see BuiltIn#SYS_FILE */
-  private static final TypedValue SYS_FILE = new Directory();
+  /** @see BuiltIn#SYS_FILE
+   *
+   * <p>A reference to {@code file} expands to an indirection via the
+   * {@link EvalEnv#SESSION}. Each session has its own file system; this
+   * ensures thread-safety and also predictability. You wouldn't want/expect
+   * the file system to be already 'expanded' in one session because another
+   * session just used it. */
+  public static final Code SYS_FILE =
+      new Code() {
+        @Override public List eval(EvalEnv evalEnv) {
+          final Session session = (Session) evalEnv.getOpt(EvalEnv.SESSION);
+          if (session == null) {
+            // We are sometimes evaluated without a session during compilation.
+            // Return null to indicate that a directory is not available.
+            return null;
+          }
+          return session.file.get().valueAs(List.class);
+        }
+
+        @Override public Describer describe(Describer describer) {
+          return describer.start("file", detail -> {});
+        }
+      };
 
   /** @see BuiltIn#SYS_PLAN */
   private static final Applicable SYS_PLAN =