rlsl 0.1.1 → 1.0.1

data/lib/rlsl/prism/type_inference/expression_inferer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ExpressionInferer
+      def initialize(infer:, lookup:, call_type_resolver:, field_type_resolver:, collection_type_resolver:)
+        @infer = infer
+        @lookup = lookup
+        @call_type_resolver = call_type_resolver
+        @field_type_resolver = field_type_resolver
+        @collection_type_resolver = collection_type_resolver
+      end
+
+      def infer_var_ref(node)
+        node.type ||= @lookup.call(node.name)
+        node
+      end
+
+      def infer_literal(node)
+        node
+      end
+
+      def infer_bool_literal(node)
+        node.type = :bool
+        node
+      end
+
+      def infer_binary_op(node)
+        @infer.call(node.left)
+        @infer.call(node.right)
+
+        node.type = Builtins.binary_op_result_type(
+          node.operator,
+          node.left.type,
+          node.right.type
+        )
+        node
+      end
+
+      def infer_unary_op(node)
+        @infer.call(node.operand)
+
+        case node.operator.to_s
+        when "-"
+          node.type = node.operand.type
+        when "!"
+          node.type = :bool
+        end
+        node
+      end
+
+      def infer_func_call(node)
+        node.args.each { |arg| @infer.call(arg) }
+        @infer.call(node.receiver) if node.receiver
+
+        node.type = @call_type_resolver.resolve(node)
+        node
+      end
+
+      def infer_field_access(node)
+        @infer.call(node.receiver)
+        node.type = @field_type_resolver.resolve(node)
+        node
+      end
+
+      def infer_swizzle(node)
+        @infer.call(node.receiver)
+        unless Builtins.valid_swizzle_for_type?(node.components, node.receiver.type)
+          raise SignatureError, "Invalid swizzle #{node.components.inspect} for #{node.receiver.type || :unknown}"
+        end
+
+        node.type = Builtins.swizzle_type(node.components)
+        node
+      end
+
+      def infer_parenthesized(node)
+        @infer.call(node.expression)
+        node.type = node.expression.type
+        node
+      end
+
+      def infer_array_literal(node)
+        node.elements.each { |element| @infer.call(element) }
+        node.type = @collection_type_resolver.resolve_array_literal(node)
+        node
+      end
+
+      def infer_array_index(node)
+        @infer.call(node.array)
+        @infer.call(node.index)
+        node.type = @collection_type_resolver.resolve_array_index(node)
+        node
+      end
+    end
+  end
+end

data/lib/rlsl/prism/type_inference/field_type_resolver.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class FieldTypeResolver
+      def initialize(uniforms:)
+        @uniforms = uniforms
+      end
+
+      def resolve(node)
+        if node.receiver.type == :uniforms
+          type = @uniforms[node.field.to_sym]
+          return type if type
+
+          raise SignatureError, "Unknown uniform field #{node.field.inspect}"
+        end
+
+        if Builtins.single_component_field?(node.field)
+          unless Builtins.valid_swizzle_for_type?(node.field, node.receiver.type)
+            raise SignatureError, "Invalid component #{node.field.inspect} for #{node.receiver.type || :unknown}"
+          end
+
+          return :float
+        end
+
+        if Builtins.swizzle?(node.field)
+          unless Builtins.valid_swizzle_for_type?(node.field, node.receiver.type)
+            raise SignatureError, "Invalid swizzle #{node.field.inspect} for #{node.receiver.type || :unknown}"
+          end
+
+          return Builtins.swizzle_type(node.field)
+        end
+
+        raise SignatureError, "Unknown field #{node.field.inspect} for #{node.receiver.type || :unknown}"
+      end
+    end
+  end
+end

data/lib/rlsl/prism/type_inference/inferer_registry.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class InfererRegistry
+      def initialize
+        @handlers = {}
+      end
+
+      def register(node_class, target = nil, method_name = nil, &block)
+        @handlers[node_class] = block || build_handler(target, method_name)
+      end
+
+      def register_methods(target, mapping)
+        mapping.each do |node_class, method_name|
+          register(node_class, target, method_name)
+        end
+      end
+
+      def infer(node, **options)
+        handler = @handlers[node.class]
+        return unless handler
+
+        handler.call(node, **options)
+      end
+
+      private
+
+      def build_handler(target, method_name)
+        lambda do |node, **options|
+          return target.send(method_name, node) if options.empty?
+
+          target.send(method_name, node, **options)
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/type_inference/scope_stack.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ScopeStack
+      def initialize
+        @scopes = [{}]
+      end
+
+      def push(initial_scope = {})
+        @scopes << normalize(initial_scope)
+      end
+
+      def pop
+        raise RLSL::InternalError, "Cannot pop the global scope" if @scopes.length == 1
+
+        @scopes.pop
+      end
+
+      def register(name, type)
+        @scopes.last[name.to_sym] = type
+      end
+
+      def lookup(name)
+        @scopes.reverse_each do |scope|
+          return scope[name.to_sym] if scope.key?(name.to_sym)
+        end
+
+        nil
+      end
+
+      def to_h
+        @scopes.each_with_object({}) do |scope, merged|
+          merged.merge!(scope)
+        end
+      end
+
+      private
+
+      def normalize(scope)
+        scope.each_with_object({}) do |(name, type), normalized|
+          normalized[name.to_sym] = type
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/type_inference/type_environment.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class TypeEnvironment
+      include TypeShapes
+
+      ARRAY_ELEMENT_SUFFIX = "_element_type"
+
+      def initialize
+        @value_scopes = ScopeStack.new
+        @array_element_scopes = ScopeStack.new
+      end
+
+      def push(initial_scope = {})
+        value_scope = {}
+        array_scope = {}
+
+        normalize(initial_scope).each do |name, type|
+          register_in_scopes(value_scope, array_scope, name, type)
+        end
+
+        @value_scopes.push(value_scope)
+        @array_element_scopes.push(array_scope)
+      end
+
+      def pop
+        @value_scopes.pop
+        @array_element_scopes.pop
+      end
+
+      def register(name, type)
+        register_in_scopes(@value_scopes, @array_element_scopes, name, type)
+      end
+
+      def lookup(name)
+        normalized_name = name.to_sym
+        return array_element_type(metadata_base_name(normalized_name)) if metadata_name?(normalized_name)
+
+        @value_scopes.lookup(normalized_name)
+      end
+
+      def array_element_type(name)
+        normalized_name = name.to_sym
+        explicit_type = @array_element_scopes.lookup(normalized_name)
+        return explicit_type if explicit_type
+
+        value_type = @value_scopes.lookup(normalized_name)
+        return TypeShapes.element_type(value_type) if TypeShapes.array?(value_type)
+
+        nil
+      end
+
+      def to_h
+        values = @value_scopes.to_h
+        elements = @array_element_scopes.to_h.each_with_object({}) do |(name, type), memo|
+          memo[metadata_name(name)] = type
+        end
+
+        values.each do |name, type|
+          next unless TypeShapes.array?(type)
+
+          elements[metadata_name(name)] ||= TypeShapes.element_type(type)
+        end
+
+        values.merge(elements)
+      end
+
+      private
+
+      def register_in_scopes(value_scope, array_scope, name, type)
+        normalized_name = name.to_sym
+
+        if metadata_name?(normalized_name)
+          write_scope(array_scope, metadata_base_name(normalized_name), type)
+          return
+        end
+
+        write_scope(value_scope, normalized_name, type)
+        return unless TypeShapes.array?(type)
+
+        write_scope(array_scope, normalized_name, TypeShapes.element_type(type))
+      end
+
+      def normalize(scope)
+        scope.each_with_object({}) do |(name, type), normalized|
+          normalized[name.to_sym] = type
+        end
+      end
+
+      def metadata_name?(name)
+        name.to_s.end_with?(ARRAY_ELEMENT_SUFFIX)
+      end
+
+      def metadata_name(name)
+        :"#{name}#{ARRAY_ELEMENT_SUFFIX}"
+      end
+
+      def metadata_base_name(name)
+        name.to_s.delete_suffix(ARRAY_ELEMENT_SUFFIX).to_sym
+      end
+
+      def write_scope(scope, name, type)
+        if scope.respond_to?(:register)
+          scope.register(name, type)
+        else
+          scope[name.to_sym] = type
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/type_inference/type_shapes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module TypeShapes
+      ArrayType = Struct.new(:element_type, :element_count) do
+        def to_sym
+          :"array_#{element_type}"
+        end
+
+        def to_s
+          to_sym.to_s
+        end
+      end
+
+      module_function
+
+      def array(element_type, length = nil)
+        ArrayType.new(element_type, length)
+      end
+
+      def array?(type)
+        type.is_a?(ArrayType)
+      end
+
+      def element_type(type)
+        return type.element_type if array?(type)
+
+        nil
+      end
+    end
+  end
+end