fusion-lang 0.0.1.alpha2 → 0.0.2

data/lib/fusion/interpreter/env.rb

@@ -22,21 +22,28 @@ module Fusion
       attr_reader :parent
 
       def initialize(parent = nil)
-        @vars = {}
+        @vars = {}     # pattern bindings, keyed by identifier
+        @context = {}  # hidden interpreter context, keyed by symbol
         @parent = parent
       end
 
-      # Unchecked insert, for interpreter-internal names (__dir__, built-ins, …).
-      def define(name, value)
-        @vars[name] = value
-        self
+      def child
+        Env.new(self)
       end
 
-      # Insert a pattern binding, rejecting a duplicate binder. Only this env's
-      # own scope is checked: a binder may shadow a name from a parent env, but
-      # must be unique within one pattern/clause.
-      def bind(name, value)
-        raise DuplicateBinding, name if @vars.key?(name)
+      # The topmost ancestor — the binding-free root a run is built on. The
+      # interpreter loads files relative to it, so they stay isolated.
+      def root
+        @parent ? @parent.root : self
+      end
+
+      # Pattern bindings:
+      # - Shadowing a binding from a parent Env is always allowed.
+      # - A duplicate identifier in the same Env is usually an error, but allowed on the REPL.
+      def bind(name, value, checked: true)
+        if checked && @vars.key?(name)
+          raise DuplicateBinding, name
+        end
 
         @vars[name] = value
       end
@@ -51,8 +58,31 @@ module Fusion
         end
       end
 
-      def child
-        Env.new(self)
+      # Hidden interpreter context:
+      # - `:dir`:  the directory @-references resolve against (a path String).
+      # - `:file`: the current file's absolute path, used for error origins (a
+      #            String; absent for inline/REPL code, which reports as origin
+      #            "code" with file "<inline>").
+      # - `:self`: the current top-level unit's own Thunk, used for recursion via a bare `@`.
+      # - `:jail`: the run's jail root confining @-resolution (an absolute path
+      #            String, or nil for unconfined). Set once on the root and, unlike
+      #            the others, never overridden by a descendant.
+      # - `:call_site`: the innermost user-code `file` a stdlib body borrows for its
+      #            errors (a String). Set on a stdlib function's clause env in
+      #            Interpreter#apply; user/inline code derives its own and omits it.
+      def set_context(key, value)
+        @context[key] = value
+        self
+      end
+
+      def context(key)
+        if @context.key?(key)
+          @context[key]
+        elsif @parent
+          @parent.context(key)
+        else
+          :__unbound__
+        end
       end
     end
   end

data/lib/fusion/interpreter/error_val.rb

@@ -9,32 +9,54 @@ module Fusion
     class ErrorVal
       attr_reader :payload
 
-      def initialize(payload)
+      def initialize(payload, runtime: false)
         @payload = payload
-        @internal = false
+        @runtime = runtime
       end
 
-      # Whether this is an interpreter-produced error (vs. a user-constructed
-      # `!expr`). Governs serialization — see docs/user/reference.md §9.3.
-      def internal_error?
-        @internal
+      # Attach the call-site `file` to a runtime error. Idempotent.
+      def with_call_site(file)
+        # Only stamp runtime-produced errors. After this check we are sure that the payload wasn't user-constructed.
+        return self unless @runtime
+        raise Unreachable, "Unexpected runtime error payload: #{@payload}" unless @payload.is_a?(Hash)
+        # Don't double stamp. Idempotency.
+        return self if @payload.key?("file")
+        # Only stamp certain errors.
+        return self unless ["builtin", "stdlib"].include?(@payload["origin"])
+
+        # Insert "file" after "origin"
+        reordered = {}
+        @payload.each do |key, value|
+          reordered[key] = value
+          reordered["file"] = file if key == "origin"
+        end
+        @payload = reordered
+        self
+      end
+
+      # Was this error runtime-produced (as opposed to user-constructed via `!expr`)?
+      # Runtime errors use lenient serialization (docs/user/reference.md §9.3) and
+      # get a call-site `file` stamped.
+      def runtime?
+        @runtime
       end
 
-      # Build an interpreter-produced error with the standardized payload shape
+      # Build a runtime-produced error with the standardized payload shape
       # documented in docs/user/reference.md §6.5.
-      def self.internal(kind:, location:, operation:, input:, message: nil)
-        error = new(
-          "kind" => kind,
-          "location" => location,
-          "operation" => operation,
-          "input" => input,
-          **(message ? { "message" => message } : {})
-        )
-
-        # Mark as "@internal" to activate lenient serialization.
-        error.instance_variable_set(:@internal, true)
-
-        error
+      def self.from_runtime(kind:, origin:, operation:, input:, file: nil, expected: nil, message: nil)
+        raise Unreachable, "an error with `expected` must not also carry a `message`" if expected && message
+
+        received_error = input.is_a?(ErrorVal)
+
+        payload = { "kind" => kind, "origin" => origin }
+        payload["file"] = file if file
+        payload["operation"] = operation
+        payload["status"] = received_error ? 1 : 0
+        payload["input"] = received_error ? input.payload : input
+        payload["expected"] = expected if expected
+        payload["message"] = message if message
+
+        new(payload, runtime: true)
       end
 
       def inspect

data/lib/fusion/interpreter/thunk.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+#
+# Lazy, memoized value of a top-level unit (a file, or an inline/REPL entry).
+
+module Fusion
+  class Interpreter
+    class Thunk
+      # We use a custom Ruby error to transmit read failures between `Interpreter.evaluate_file`
+      # (which runs in the @compute block) and the Thunk to enforce their connection.
+      # If `Interpreter.evaluate_file` were to be used outside of a Thunk, the Ruby error would
+      # bubble and trigger an `internal_error` later on.
+      class ReadFailure < StandardError; end
+
+      def initialize(&compute)
+        @compute = compute
+        @state = :unforced # :unforced | :forcing | :done
+        @value = nil # memoized result: runtime value/error | ReadFailure
+      end
+
+      # `operation`/`input`/`site` describe the @-reference forcing this thunk.
+      # They are NOT passed to `@compute`, because they differ when evaluating the same
+      # Thunk for different @-references. They MUST NOT become part or the memoized value.
+      def force(operation: "loading code", input: NULL, site: { origin: "code", file: nil })
+        result = case @state
+        when :done
+          @value
+        when :forcing
+          # Re-entering while still computing results in a non-productive data cycle. Not memoized.
+          ErrorVal.from_runtime(kind: "reference_error", **site, operation: operation, input: input, message: "non-productive data cycle")
+        when :unforced
+          @state = :forcing
+          begin
+            @value = @compute.call
+          rescue ReadFailure => e
+            # Memoize the Ruby error itself. Turn it into a Fusion runtime error below.
+            @value = e
+          end
+          @state = :done
+          @value
+        end
+
+        case result
+        when ReadFailure
+          ErrorVal.from_runtime(kind: "reference_error", **site, operation: operation, input: input, message: result.message)
+        else
+          result
+        end
+      end
+    end
+  end
+end