rlsl 1.0.0 → 1.0.1

data/lib/rlsl/prism/ast_visitor.rb

@@ -3,6 +3,9 @@
 require "prism"
 require "set"
 
+require_relative "node_traversal"
+require_relative "errors"
+require_relative "parameter_list"
 require_relative "ast_visitor/visitor_registry"
 require_relative "ast_visitor/scope_context"
 require_relative "ast_visitor/expression_visiting"
@@ -11,9 +14,8 @@ require_relative "ast_visitor/definition_visiting"
 
 module RLSL
   module Prism
-    class UnsupportedSyntaxError < StandardError; end
-
     class ASTVisitor
+      MAX_AST_DEPTH = 512
       BINARY_OPERATORS = %w[+ - * / % == != < > <= >= && ||].freeze
       UNARY_OPERATORS = %w[- !].freeze
       TRANSPARENT_NODES = VisitorRegistry::TRANSPARENT_NODES
@@ -34,7 +36,20 @@ module RLSL
       def initialize(context = {})
         @context = context
         @uniforms = context[:uniforms] || {}
-        @scope_context = ScopeContext.new(params: context[:params] || [])
+        @source_name = context[:source_name] || "(shader source)"
+        @line_offset = context[:line_offset].to_i
+        params = context[:params] || []
+        @scope_context = ScopeContext.new(params: params)
+        positional_types = params.each_with_index.to_h do |name, index|
+          [name.to_sym, %i[vec2 vec2 uniforms][index]]
+        end
+        @parameter_types = { frag_coord: :vec2, resolution: :vec2, u: :uniforms }.merge(positional_types)
+        @parameter_bindings = { frag_coord: :frag_coord, resolution: :resolution, u: :u }
+        @implicit_loop_index = 0
+        @source_identifiers = Set.new
+        params.each_with_index do |name, index|
+          @parameter_bindings[name.to_sym] = %i[frag_coord resolution u][index]
+        end
       end
 
       def parse(source)
@@ -42,10 +57,17 @@ module RLSL
 
         unless result.success?
           errors = result.errors.map(&:message).join(", ")
-          raise "Parse error: #{errors}"
+          raise RLSL::ParseError, "Parse error: #{errors}"
         end
 
         program = result.value
+        if NodeTraversal.depth_exceeds?(program, MAX_AST_DEPTH)
+          raise UnsupportedSyntaxError, "Shader syntax nesting exceeds #{MAX_AST_DEPTH} nodes"
+        end
+        @source_identifiers = NodeTraversal.each(program).filter_map do |node|
+          node.name.to_sym if node.respond_to?(:name)
+        end.to_set
+
         visit(program)
       end
 
@@ -53,11 +75,17 @@ module RLSL
         return nil if node.nil?
 
         method_name = NODE_VISITORS[node.class]
-        return send(method_name, node) if method_name
-
-        raise UnsupportedSyntaxError, "Unsupported Prism node: #{node.class}" unless transparent_node?(node)
-
-        visit_default(node)
+        result = if method_name
+                   send(method_name, node)
+                 else
+                   raise UnsupportedSyntaxError, "Unsupported Prism node: #{node.class}" unless transparent_node?(node)
+
+                   visit_default(node)
+                 end
+        attach_source_location(result, node.location)
+      rescue RLSL::Error => error
+        error.with_source_location(source_location(node.location))
+        raise
       end
 
       private
@@ -89,20 +117,15 @@ module RLSL
       end
 
       def infer_param_type(name)
-        case name
-        when :frag_coord, :resolution
-          :vec2
-        when :u
-          :uniforms
-        else
-          nil
-        end
+        @parameter_types[name.to_sym]
       end
 
-      def extract_required_params(node)
-        return [] unless node
+      def emitted_parameter_name(name)
+        @parameter_bindings[name.to_sym] || name.to_sym
+      end
 
-        node.requireds&.map { |param| param.name.to_sym } || []
+      def extract_required_params(node)
+        ParameterList.required_names(node).map(&:to_sym)
       end
 
       def extract_block_params(node)
@@ -115,6 +138,18 @@ module RLSL
         @scope_context.parameter?(name)
       end
 
+      def fragment_parameter_reference?(name)
+        @scope_context.root_parameter?(name)
+      end
+
+      def emitted_assignment_name(name)
+        if fragment_parameter_reference?(name) && infer_param_type(name) == :uniforms
+          raise UnsupportedSyntaxError, "The fragment uniform parameter cannot be reassigned"
+        end
+
+        fragment_parameter_reference?(name) ? emitted_parameter_name(name) : name
+      end
+
       def known_variable?(name)
         @scope_context.known_variable?(name)
       end
@@ -122,6 +157,29 @@ module RLSL
       def declare_variable(name)
         @scope_context.declare(name)
       end
+
+      def next_implicit_loop_variable
+        loop do
+          name = :"_rlsl_i#{@implicit_loop_index}"
+          @implicit_loop_index += 1
+          return name unless @source_identifiers.include?(name)
+        end
+      end
+
+      def attach_source_location(result, prism_location)
+        return result unless result.is_a?(IR::Node)
+
+        result.location ||= source_location(prism_location)
+        result
+      end
+
+      def source_location(prism_location)
+        RLSL::SourceLocation.new(
+          source_name: @source_name,
+          line: @line_offset + prism_location.start_line,
+          column: prism_location.start_column + 1
+        )
+      end
     end
   end
 end

data/lib/rlsl/prism/builtins/function_registry.rb

@@ -5,16 +5,16 @@ module RLSL
     module Builtins
       module FunctionRegistry
         ALL_TARGETS = %i[c glsl wgsl msl].freeze
-        META_TYPES = %i[any same first second third].freeze
+        META_TYPES = %i[any same first second third common floating interpolated].freeze
 
         FUNCTIONS = {
           vec2: { args: %i[any any], returns: :vec2, variadic: true, min_args: 1 },
           vec3: { args: %i[any any any], returns: :vec3, variadic: true, min_args: 1 },
           vec4: { args: %i[any any any any], returns: :vec4, variadic: true, min_args: 1 },
 
-          mat2: { args: %i[any any any any], returns: :mat2, variadic: true, min_args: 1 },
-          mat3: { args: %i[any any any any any any any any any], returns: :mat3, variadic: true, min_args: 1 },
-          mat4: { args: %i[any any any any any any any any any any any any any any any any], returns: :mat4, variadic: true, min_args: 1 },
+          mat2: { args: %i[any any any any], returns: :mat2, variadic: true, min_args: 1, targets: %i[glsl wgsl msl] },
+          mat3: { args: %i[any any any any any any any any any], returns: :mat3, variadic: true, min_args: 1, targets: %i[glsl wgsl msl] },
+          mat4: { args: %i[any any any any any any any any any any any any any any any any], returns: :mat4, variadic: true, min_args: 1, targets: %i[glsl wgsl msl] },
 
           sin: { args: [:float], returns: :float },
           cos: { args: [:float], returns: :float },
@@ -27,18 +27,18 @@ module RLSL
           pow: { args: %i[float float], returns: :float },
           exp: { args: [:float], returns: :float },
           log: { args: [:float], returns: :float },
-          sqrt: { args: [:any], returns: :same },
+          sqrt: { args: [:any], returns: :floating },
 
           abs: { args: [:any], returns: :same },
           sign: { args: [:any], returns: :same },
-          floor: { args: [:any], returns: :same },
-          ceil: { args: [:any], returns: :same },
-          fract: { args: [:any], returns: :same },
-          mod: { args: %i[any float], returns: :first },
-          min: { args: %i[any any], returns: :first },
-          max: { args: %i[any any], returns: :first },
-          clamp: { args: %i[any any any], returns: :first },
-          mix: { args: %i[any any float], returns: :first },
+          floor: { args: [:any], returns: :floating },
+          ceil: { args: [:any], returns: :floating },
+          fract: { args: [:any], returns: :floating },
+          mod: { args: %i[float float], returns: :float },
+          min: { args: %i[any any], returns: :common },
+          max: { args: %i[any any], returns: :common },
+          clamp: { args: %i[any any any], returns: :common },
+          mix: { args: %i[any any float], returns: :interpolated },
           step: { args: %i[float any], returns: :second },
           smoothstep: { args: %i[float float any], returns: :third },
 
@@ -50,23 +50,23 @@ module RLSL
           reflect: { args: %i[any any], returns: :first },
           refract: { args: %i[any any float], returns: :first },
 
-          hash21: { args: [:vec2], returns: :float },
-          hash22: { args: [:vec2], returns: :vec2 },
+          hash21: { args: [:vec2], returns: :float, targets: [:c] },
+          hash22: { args: [:vec2], returns: :vec2, targets: [:c] },
 
-          lessThan: { args: %i[any any], returns: :bool },
-          lessThanEqual: { args: %i[any any], returns: :bool },
-          greaterThan: { args: %i[any any], returns: :bool },
-          greaterThanEqual: { args: %i[any any], returns: :bool },
-          equal: { args: %i[any any], returns: :bool },
-          notEqual: { args: %i[any any], returns: :bool },
+          lessThan: { args: %i[any any], returns: :bool, targets: [] },
+          lessThanEqual: { args: %i[any any], returns: :bool, targets: [] },
+          greaterThan: { args: %i[any any], returns: :bool, targets: [] },
+          greaterThanEqual: { args: %i[any any], returns: :bool, targets: [] },
+          equal: { args: %i[any any], returns: :bool, targets: [] },
+          notEqual: { args: %i[any any], returns: :bool, targets: [] },
 
           inverse: { args: [:any], returns: :same, targets: %i[glsl wgsl msl] },
           transpose: { args: [:any], returns: :same, targets: %i[glsl wgsl msl] },
           determinant: { args: [:any], returns: :float, targets: %i[glsl wgsl msl] },
 
-          texture2D: { args: %i[sampler2D vec2], returns: :vec4 },
-          texture: { args: %i[sampler2D vec2], returns: :vec4 },
-          textureLod: { args: %i[sampler2D vec2 float], returns: :vec4 }
+          texture2D: { args: %i[sampler2D vec2], returns: :vec4, targets: %i[glsl wgsl msl] },
+          texture: { args: %i[sampler2D vec2], returns: :vec4, targets: %i[glsl wgsl msl] },
+          textureLod: { args: %i[sampler2D vec2 float], returns: :vec4, targets: %i[glsl wgsl msl] }
         }.freeze
 
         module_function
@@ -101,6 +101,19 @@ module RLSL
           when :first then arg_types.first
           when :second then arg_types[1]
           when :third then arg_types[2]
+          when :common
+            type = OperatorRules.common_type(arg_types)
+            type if numeric_type?(type)
+          when :floating
+            type = arg_types.first
+            return :float if type == :int
+
+            type if type == :float || OperatorRules.vector_type?(type)
+          when :interpolated
+            type = OperatorRules.common_type(arg_types.first(2))
+            return :float if type == :int
+
+            type if numeric_type?(type)
           when Symbol then rule
           end
         end
@@ -108,6 +121,10 @@ module RLSL
         def explicit_type?(type)
           type.is_a?(Symbol) && !META_TYPES.include?(type)
         end
+
+        def numeric_type?(type)
+          OperatorRules.scalar_type?(type) || OperatorRules.vector_type?(type)
+        end
       end
     end
   end

data/lib/rlsl/prism/builtins/operator_rules.rb

@@ -39,6 +39,7 @@ module RLSL
 
         def binary_op_result_type(op, left_type, right_type)
           op_kind = BINARY_OPERATORS[op.to_s]
+          validate_operand_shapes!(op, left_type, right_type)
 
           case op_kind
           when :comparison, :logical
@@ -78,6 +79,14 @@ module RLSL
           %i[float int].include?(type)
         end
 
+        def common_type(types)
+          types = Array(types).compact.uniq
+          return types.first if types.length == 1
+          return :float if types.sort == %i[float int]
+
+          nil
+        end
+
         def scalar_arithmetic_result_type(op, left_type, right_type)
           return :float unless scalar_type?(left_type) && scalar_type?(right_type)
           return :float if op.to_s == "/"
@@ -93,6 +102,21 @@ module RLSL
           when :mat4 then :vec4
           end
         end
+
+        def validate_operand_shapes!(op, left_type, right_type)
+          if vector_type?(left_type) && vector_type?(right_type) && left_type != right_type
+            raise SignatureError, "Vector size mismatch for #{op}: #{left_type} and #{right_type}"
+          end
+
+          if matrix_type?(left_type) && vector_type?(right_type) && matrix_vector_result(left_type) != right_type
+            raise SignatureError, "Matrix/vector size mismatch for #{op}: #{left_type} and #{right_type}"
+          end
+
+          return unless vector_type?(left_type) && matrix_type?(right_type)
+          return if left_type == matrix_vector_result(right_type)
+
+          raise SignatureError, "Vector/matrix size mismatch for #{op}: #{left_type} and #{right_type}"
+        end
       end
     end
   end

data/lib/rlsl/prism/builtins/swizzle_rules.rb

@@ -12,7 +12,7 @@ module RLSL
         }.freeze
 
         SINGLE_COMPONENT_FIELDS = %w[x y z w r g b a s t p q].freeze
-        SWIZZLE_PATTERNS = /\A[xyzwrgba]{2,4}\z/
+        SWIZZLE_PATTERNS = /\A(?:[xyzw]{2,4}|[rgba]{2,4}|[stpq]{2,4})\z/
 
         module_function
 
@@ -32,6 +32,15 @@ module RLSL
           else :float
           end
         end
+
+        def valid_for_type?(components, receiver_type)
+          vector_size = { vec2: 2, vec3: 3, vec4: 4 }[receiver_type]
+          return false unless vector_size
+
+          components.to_s.each_char.all? do |component|
+            SWIZZLE_COMPONENTS.fetch(component) < vector_size
+          end
+        end
       end
     end
   end

data/lib/rlsl/prism/builtins.rb

@@ -51,6 +51,10 @@ module RLSL
           SwizzleRules.swizzle_type(components)
         end
 
+        def valid_swizzle_for_type?(components, receiver_type)
+          SwizzleRules.valid_for_type?(components, receiver_type)
+        end
+
         def resolve_return_type(rule, arg_types)
           FunctionRegistry.resolve_return_type(rule, arg_types)
         end
@@ -71,6 +75,10 @@ module RLSL
           OperatorRules.scalar_type?(type)
         end
 
+        def common_type(types)
+          OperatorRules.common_type(types)
+        end
+
         def matrix_vector_result(matrix_type)
           OperatorRules.matrix_vector_result(matrix_type)
         end

data/lib/rlsl/prism/emitters/base_emitter/control_flow_emission.rb

@@ -6,8 +6,7 @@ module RLSL
       class BaseEmitter
         module ControlFlowEmission
           def emit_tuple_return(node)
-            elements = node.elements.map { |elem| emit(elem) }.join(", ")
-            "#{indent}return (#{current_return_struct_name}){#{elements}};\n"
+            "#{indent}return #{emit_tuple_value(node)};\n"
           end
 
           def emit_if_statement(node)
@@ -17,15 +16,18 @@ module RLSL
           def emit_conditional(node, needs_return:)
             condition = emit(node.condition)
             then_code = emit_branch(node.then_branch, needs_return: needs_return)
+            declarations = emit_hoisted_declarations(node)
 
-            return "#{indent}if (#{condition}) {\n#{then_code}#{indent}}#{needs_return ? "\n" : ""}" unless node.else_branch
+            unless node.else_branch
+              return "#{declarations}#{indent}if (#{condition}) {\n#{then_code}#{indent}}#{needs_return ? "\n" : ""}"
+            end
 
             if elsif_node?(node.else_branch)
               elsif_code = emit_elsif(node.else_branch, needs_return: needs_return)
-              "#{indent}if (#{condition}) {\n#{then_code}#{indent}} #{elsif_code}#{needs_return ? "\n" : ""}"
+              "#{declarations}#{indent}if (#{condition}) {\n#{then_code}#{indent}} #{elsif_code}#{needs_return ? "\n" : ""}"
             else
               else_code = emit_branch(node.else_branch, needs_return: needs_return)
-              "#{indent}if (#{condition}) {\n#{then_code}#{indent}} else {\n#{else_code}#{indent}}#{needs_return ? "\n" : ""}"
+              "#{declarations}#{indent}if (#{condition}) {\n#{then_code}#{indent}} else {\n#{else_code}#{indent}}#{needs_return ? "\n" : ""}"
             end
           end
 
@@ -53,16 +55,26 @@ module RLSL
           end
 
           def emit_return(node)
-            node.expression ? "return #{emit(node.expression)}" : "return"
+            if node.expression.is_a?(IR::ArrayLiteral) && @return_struct_name_stack.any?
+              return "return #{emit_tuple_value(node.expression)}"
+            end
+
+            node.expression ? "return #{emit_return_expression(node.expression)}" : "return"
           end
 
           def emit_for_loop(node)
-            var = node.variable
+            variable = node.variable
+            counter = loop_variable_mutated?(node) ? next_temporary_name("i") : variable
             start_val = emit(node.range_start)
             end_val = emit(node.range_end)
             body = emit_indented_block(node.body)
+            body = "#{indent}  #{type_name(:int)} #{variable} = #{counter};\n#{body}" if counter != variable
+
+            comparison = node.exclude_end ? "<" : "<="
+            return "for (int #{counter} = #{start_val}; #{counter} #{comparison} #{end_val}; #{counter}++) {\n#{body}#{indent}}" if node.range_end.is_a?(IR::Literal)
 
-            "for (int #{var} = #{start_val}; #{var} < #{end_val}; #{var}++) {\n#{body}#{indent}}"
+            bound = next_temporary_name("end")
+            "int #{bound} = #{end_val};\n#{indent}for (int #{counter} = #{start_val}; #{counter} #{comparison} #{bound}; #{counter}++) {\n#{body}#{indent}}"
           end
 
           def emit_while_loop(node)
@@ -76,6 +88,37 @@ module RLSL
             "break"
           end
 
+          def emit_hoisted_declarations(node)
+            node.hoisted_variables.map do |name, type|
+              "#{indent}#{type_name(type || :float)} #{name};\n"
+            end.join
+          end
+
+          def emit_tuple_value(node)
+            expected_types = Array(current_return_type)
+            elements = node.elements.each_with_index.map do |element, index|
+              emit_typed_argument(element, expected_types[index])
+            end.join(", ")
+            "(#{current_return_struct_name}){#{elements}}"
+          end
+
+          def emit_return_expression(node)
+            emit_typed_argument(node, current_return_type)
+          end
+
+          def loop_variable_mutated?(node)
+            IR::Traversal.each(node.body).any? do |current|
+              case current
+              when IR::Assignment
+                current.target.is_a?(IR::VarRef) && current.target.name == node.variable
+              when IR::MultipleAssignment
+                current.targets.any? { |target| target.name == node.variable }
+              else
+                false
+              end
+            end
+          end
+
         end
       end
     end

data/lib/rlsl/prism/emitters/base_emitter/definition_emission.rb

@@ -12,14 +12,14 @@ module RLSL
             end.join(", ")
 
             if node.return_type.is_a?(Array)
-              @current_return_struct_name = "#{name}_result"
               struct_def = emit_result_struct(name, node.return_type)
-              body = emit_indented_block(node.body, needs_return: true)
-              @current_return_struct_name = nil
-              "#{struct_def}static inline #{name}_result #{name}(#{params}) {\n#{body}\n#{indent}}\n"
+              body = with_return_struct_name("#{name}_result") do
+                with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+              end
+              "#{struct_def}#{function_qualifier}#{name}_result #{name}(#{params}) {\n#{body}#{indent}}\n"
             else
-              body = emit_indented_block(node.body, needs_return: true)
-              "static inline #{type_name(node.return_type || :float)} #{name}(#{params}) {\n#{body}\n#{indent}}\n"
+              body = with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+              "#{function_qualifier}#{type_name(node.return_type || :float)} #{name}(#{params}) {\n#{body}#{indent}}\n"
             end
           end
 
@@ -29,11 +29,18 @@ module RLSL
           end
 
           def current_return_struct_name
-            @current_return_struct_name || "result"
+            @return_struct_name_stack.last || "result"
           end
 
           def emit_array_literal(node, for_static_init: false)
-            elements = node.elements.map { |elem| emit_for_static_init(elem, for_static_init) }.join(", ")
+            element_type = TypeShapes.element_type(node.type)
+            elements = node.elements.map do |element|
+              if for_static_init
+                emit_for_static_init(element, true)
+              else
+                emit_typed_argument(element, element_type)
+              end
+            end.join(", ")
             "{#{elements}}"
           end
 
@@ -66,7 +73,7 @@ module RLSL
               elements = emit_array_literal(node.initializer, for_static_init: true)
               "#{prefix}#{elem_type} #{node.name}[#{size}] = #{elements}"
             else
-              value = node.is_const ? emit_for_static_init(node.initializer, true) : emit(node.initializer)
+              value = node.is_static ? emit_for_static_init(node.initializer, true) : emit(node.initializer)
               "#{prefix}#{type_name(node.type || :float)} #{node.name} = #{value}"
             end
           end
@@ -76,6 +83,8 @@ module RLSL
 
             if node.value.is_a?(IR::FuncCall)
               emit_multi_return_assignment(node, value_code)
+            elsif node.value.is_a?(IR::ArrayLiteral)
+              emit_literal_assignment(node)
             else
               emit_indexed_assignment(node, value_code)
             end
@@ -85,18 +94,39 @@ module RLSL
 
           def emit_multi_return_assignment(node, value_code)
             func_name = node.value.name
-            lines = ["#{func_name}_result _tmp_#{func_name} = #{value_code}"]
+            temporary = next_temporary_name("result")
+            lines = [emit_temporary_declaration("#{func_name}_result", temporary, value_code)]
             node.targets.each_with_index do |target, index|
-              lines << "#{type_name(target.type || :float)} #{target.name} = _tmp_#{func_name}.v#{index}"
+              lines << "#{emit_multiple_assignment_target(target, node.declarations[index])} = #{temporary}.v#{index}"
             end
             lines.join(";\n#{indent}")
           end
 
           def emit_indexed_assignment(node, value_code)
             node.targets.each_with_index.map do |target, index|
-              "#{type_name(target.type || :float)} #{target.name} = #{value_code}[#{index}]"
+              "#{emit_multiple_assignment_target(target, node.declarations[index])} = #{value_code}[#{index}]"
             end.join(";\n#{indent}")
           end
+
+          def emit_literal_assignment(node)
+            temporaries = node.value.elements.map do |element|
+              name = next_temporary_name("value")
+              [name, emit_temporary_declaration(type_name(element.type || :float), name, emit(element))]
+            end
+            lines = temporaries.map(&:last)
+            node.targets.each_with_index do |target, index|
+              lines << "#{emit_multiple_assignment_target(target, node.declarations[index])} = #{temporaries[index].first}"
+            end
+            lines.join(";\n#{indent}")
+          end
+
+          def emit_multiple_assignment_target(target, declaration)
+            declaration ? "#{type_name(target.type || :float)} #{target.name}" : target.name.to_s
+          end
+
+          def emit_temporary_declaration(type, name, value)
+            "#{type} #{name} = #{value}"
+          end
         end
       end
     end

data/lib/rlsl/prism/emitters/base_emitter/expression_emission.rb

@@ -7,6 +7,14 @@ module RLSL
         module ExpressionEmission
           def emit_var_decl(node)
             type = type_name(node.type || :float)
+            return "#{type} #{node.name}" unless node.initializer
+
+            if node.initializer.is_a?(IR::ArrayLiteral)
+              value = emit(node.initializer)
+              element_type = type_name(TypeShapes.element_type(node.type) || :float)
+              return "#{element_type} #{node.name}[#{node.initializer.elements.length}] = #{value}"
+            end
+
             value = emit(node.initializer)
             "#{type} #{node.name} = #{value}"
           end
@@ -16,7 +24,7 @@ module RLSL
           end
 
           def emit_literal(node)
-            format_number(node.value)
+            format_number(node.value, type: node.type)
           end
 
           def emit_bool_literal(node)
@@ -24,13 +32,17 @@ module RLSL
           end
 
           def emit_binary_op(node)
-            left = emit_with_precedence(node.left, node.operator)
-            right = emit_with_precedence(node.right, node.operator)
+            left = emit_with_precedence(node.left, node.operator, side: :left)
+            right = emit_with_precedence(node.right, node.operator, side: :right)
             "#{left} #{node.operator} #{right}"
           end
 
           def emit_unary_op(node)
-            "#{node.operator}#{emit(node.operand)}"
+            operand = emit(node.operand)
+            operand = "(#{operand})" if node.operand.is_a?(IR::BinaryOp) ||
+                                        node.operand.is_a?(IR::Ternary) ||
+                                        node.operand.is_a?(IR::UnaryOp)
+            "#{node.operator}#{operand}"
           end
 
           def emit_func_call(node)
@@ -85,6 +97,10 @@ module RLSL
                     end
             "#{array}[#{index}]"
           end
+
+          def emit_typed_argument(node, _expected_type)
+            emit(node)
+          end
         end
       end
     end

data/lib/rlsl/prism/emitters/base_emitter/statement_emission.rb

@@ -27,10 +27,16 @@ module RLSL
 
           def emit_terminal_statement(node)
             return emit(node, needs_return: true) if node.is_a?(IR::IfStatement)
+            if node.is_a?(IR::VarDecl)
+              return "#{emit_statement(node)}#{indent}return #{node.name};\n"
+            end
+            if node.is_a?(IR::Assignment)
+              return "#{emit_statement(node)}#{indent}return #{emit(node.target)};\n"
+            end
             return emit_statement(node) if terminal_passthrough_node?(node)
             return emit_tuple_return(node) if node.is_a?(IR::ArrayLiteral)
 
-            "#{indent}return #{emit(node)};\n"
+            "#{indent}return #{emit_return_expression(node)};\n"
           end
 
           def emit_branch(node, needs_return:)