fusion-lang 0.0.1.alpha2 → 0.0.1

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 => failure
+            # Memoize the Ruby error itself. Turn it into a Fusion runtime error below.
+            @value = failure
+          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