mt-lang 0.3.4 → 0.3.5

data/lib/milk_tea/core/semantic_analyzer/foreign_functions.rb

@@ -1,155 +1,158 @@
 # frozen_string_literal: true
 
 module MilkTea
-  class SemanticAnalyzer::Checker
-    private
+  class SemanticAnalyzer
+    class Checker
+      private
 
-    def validate_consuming_foreign_parameter!(type, function_name:, parameter_name:)
-      if type.is_a?(Types::Nullable) || !(opaque_type?(type) || pointer_type?(type))
-        raise_sema_error("consuming parameter #{parameter_name} of #{function_name} must use a non-null opaque or ptr[...] type")
+      def validate_consuming_foreign_parameter!(type, function_name:, parameter_name:)
+        if type.is_a?(Types::Nullable) || !(opaque_type?(type) || pointer_type?(type))
+          raise_sema_error("consuming parameter #{parameter_name} of #{function_name} must use a non-null opaque or ptr[...] type")
+        end
       end
-    end
-
-    def foreign_boundary_nullable_pointer_like_base?(base)
-      return true if base.is_a?(Types::Function) || base.is_a?(Types::Proc)
-      return true if opaque_type?(base)
-      return true if base == @ctx.types.fetch("cstr")
 
-      pointer_type?(base) || const_pointer_type?(base) || ref_type?(base)
-    end
-
-    def reject_foreign_nullable_value_type!(type, function_name:, parameter_name:)
-      return unless type.is_a?(Types::Nullable)
-      return if foreign_boundary_nullable_pointer_like_base?(type.base)
+      def foreign_boundary_nullable_pointer_like_base?(base)
+        return true if base.is_a?(Types::Function) || base.is_a?(Types::Proc)
+        return true if opaque_type?(base)
+        return true if base == @ctx.types.fetch("cstr")
 
-      location = parameter_name ? "parameter #{parameter_name}" : "return type"
-      raise_sema_error("#{location} of foreign/external function #{function_name} cannot use nullable value type #{type}; nullable at an FFI boundary is only supported for pointer-like types (use ptr[...]? or pass an explicit struct)")
-    end
+        pointer_type?(base) || const_pointer_type?(base) || ref_type?(base)
+      end
 
-    def foreign_cstr_boundary_parameter?(parameter)
-      parameter.boundary_type == @ctx.types.fetch("cstr") && parameter.type == @ctx.types.fetch("str")
-    end
+      def reject_foreign_nullable_value_type!(type, function_name:, parameter_name:)
+        return unless type.is_a?(Types::Nullable)
+        return if foreign_boundary_nullable_pointer_like_base?(type.base)
 
-    def foreign_cstr_argument_compatible?(actual_type, parameter, expression:)
-      types_compatible?(actual_type, parameter.type, expression:) || actual_type == @ctx.types.fetch("cstr")
-    end
-
-    def foreign_parameter_boundary_type(param, public_type, type_params:, type_param_constraints: current_type_param_constraints)
-      return resolve_type_ref(param.boundary_type, type_params:, type_param_constraints:) if param.boundary_type
-      return const_pointer_to(public_type) if param.mode == :in
-      return pointer_to(foreign_slot_boundary_value_type(public_type)) if [:out, :inout].include?(param.mode)
+        location = parameter_name ? "parameter #{parameter_name}" : "return type"
+        raise_sema_error("#{location} of foreign/external function #{function_name} cannot use nullable value type #{type}; nullable at an FFI boundary is only supported for pointer-like types (use ptr[...]? or pass an explicit struct)")
+      end
 
-      nil
-    end
+      def foreign_cstr_boundary_parameter?(parameter)
+        parameter.boundary_type == @ctx.types.fetch("cstr") && parameter.type == @ctx.types.fetch("str")
+      end
 
-    def foreign_slot_boundary_value_type(public_type)
-      if public_type.is_a?(Types::Nullable) && pointer_type?(public_type.base)
-        return public_type.base
+      def foreign_cstr_argument_compatible?(actual_type, parameter, expression:)
+        types_compatible?(actual_type, parameter.type, expression:) || actual_type == @ctx.types.fetch("cstr")
       end
 
-      public_type
-    end
+      def foreign_parameter_boundary_type(param, public_type, type_params:, type_param_constraints: current_type_param_constraints)
+        return resolve_type_ref(param.boundary_type, type_params:, type_param_constraints:) if param.boundary_type
+        return const_pointer_to(public_type) if param.mode == :in
+        return pointer_to(foreign_slot_boundary_value_type(public_type)) if [:out, :inout].include?(param.mode)
 
-    def validate_in_foreign_parameter!(public_type, boundary_type, function_name:, parameter_name:)
-      unless const_pointer_type?(boundary_type)
-        raise_sema_error("in parameter #{parameter_name} of #{function_name} must lower to const_ptr[...], got #{boundary_type || public_type}")
+        nil
       end
 
-      expected_public_type = pointee_type(boundary_type)
-      return if expected_public_type == public_type
-      return if expected_public_type == @ctx.types.fetch("void")
-      return if foreign_identity_projection_compatible?(public_type, expected_public_type)
-
-      raise_sema_error("in parameter #{parameter_name} of #{function_name} cannot map #{public_type} as #{boundary_type}")
-    end
+      def foreign_slot_boundary_value_type(public_type)
+        if public_type.is_a?(Types::Nullable) && pointer_type?(public_type.base)
+          return public_type.base
+        end
 
-    def foreign_mapping_public_alias_name(name)
-      "#{name}_public"
-    end
+        public_type
+      end
 
-    def validate_foreign_boundary_type!(public_type, boundary_type, function_name:, parameter_name:)
-      return if boundary_type == public_type
-      return if boundary_type == @ctx.types.fetch("cstr") && public_type == @ctx.types.fetch("str")
-      return if foreign_span_boundary_compatible?(public_type, boundary_type)
-      return if foreign_char_pointer_buffer_boundary_compatible?(public_type, boundary_type)
-      return if foreign_identity_projection_compatible?(public_type, boundary_type)
+      def validate_in_foreign_parameter!(public_type, boundary_type, function_name:, parameter_name:)
+        unless const_pointer_type?(boundary_type)
+          raise_sema_error("in parameter #{parameter_name} of #{function_name} must lower to const_ptr[...], got #{boundary_type || public_type}")
+        end
 
-      raise_sema_error("foreign parameter #{parameter_name} of #{function_name} cannot map #{public_type} as #{boundary_type}")
-    end
+        expected_public_type = pointee_type(boundary_type)
+        return if expected_public_type == public_type
+        return if expected_public_type == @ctx.types.fetch("void")
+        return if foreign_identity_projection_compatible?(public_type, expected_public_type)
 
-    def foreign_function_binding?(binding)
-      binding.ast.is_a?(AST::ForeignFunctionDecl)
-    end
+        raise_sema_error("in parameter #{parameter_name} of #{function_name} cannot map #{public_type} as #{boundary_type}")
+      end
 
-    def foreign_mapping_expression(decl)
-      return decl.mapping unless foreign_mapping_auto_call_shorthand?(decl.mapping)
+      def foreign_mapping_public_alias_name(name)
+        "#{name}_public"
+      end
 
-      AST::Call.new(
-        callee: decl.mapping,
-        arguments: decl.params.map { |param| AST::Argument.new(name: nil, value: AST::Identifier.new(name: param.name)) },
-      )
-    end
+      def validate_foreign_boundary_type!(public_type, boundary_type, function_name:, parameter_name:)
+        return if boundary_type == public_type
+        return if boundary_type == @ctx.types.fetch("cstr") && public_type == @ctx.types.fetch("str")
+        return if foreign_span_boundary_compatible?(public_type, boundary_type)
+        return if foreign_char_pointer_buffer_boundary_compatible?(public_type, boundary_type)
+        return if foreign_identity_projection_compatible?(public_type, boundary_type)
 
-    def foreign_mapping_auto_call_shorthand?(expression)
-      case expression
-      when AST::Identifier
-        true
-      when AST::MemberAccess
-        foreign_mapping_auto_call_shorthand?(expression.receiver)
-      when AST::Specialization
-        foreign_mapping_auto_call_shorthand?(expression.callee)
-      else
-        false
+        raise_sema_error("foreign parameter #{parameter_name} of #{function_name} cannot map #{public_type} as #{boundary_type}")
       end
-    end
 
-    def foreign_argument_expression(argument)
-      if argument.value.is_a?(AST::UnaryOp) && ["out", "in", "inout"].include?(argument.value.operator)
-        argument.value.operand
-      else
-        argument.value
+      def foreign_function_binding?(binding)
+        binding.ast.is_a?(AST::ForeignFunctionDecl)
       end
-    end
 
-    def foreign_argument_legacy_passing_mode(argument)
-      return nil unless argument.value.is_a?(AST::UnaryOp) && ["out", "in", "inout"].include?(argument.value.operator)
+      def foreign_mapping_expression(decl)
+        return decl.mapping unless foreign_mapping_auto_call_shorthand?(decl.mapping)
 
-      argument.value.operator
-    end
+        AST::Call.new(
+          callee: decl.mapping,
+          arguments: decl.params.map { |param| AST::Argument.new(name: nil, value: AST::Identifier.new(name: param.name)) },
+        )
+      end
 
-    def foreign_argument_actual_type(parameter, argument, scopes:, function_name:, expected_type: parameter.type)
-      case parameter.passing_mode
-      when :plain
-        infer_expression(argument.value, scopes:, expected_type:)
-      when :consuming
-        foreign_consuming_argument_binding(parameter, argument, scopes:, function_name:)
-        parameter.type
-      when :in, :out, :inout
-        if (legacy_passing_mode = foreign_argument_legacy_passing_mode(argument))
-          raise_sema_error("argument #{parameter.name} to #{function_name} must not use #{legacy_passing_mode}; directional passing is declared on #{function_name}")
+      def foreign_mapping_auto_call_shorthand?(expression)
+        case expression
+        when AST::Identifier
+          true
+        when AST::MemberAccess
+          foreign_mapping_auto_call_shorthand?(expression.receiver)
+        when AST::Specialization
+          foreign_mapping_auto_call_shorthand?(expression.callee)
+        else
+          false
         end
+      end
 
-        if parameter.passing_mode == :in
-          infer_expression(argument.value, scopes:, expected_type: expected_type)
+      def foreign_argument_expression(argument)
+        if argument.value.is_a?(AST::UnaryOp) && ["out", "in", "inout"].include?(argument.value.operator)
+          argument.value.operand
         else
-          infer_lvalue(argument.value, scopes:)
+          argument.value
         end
-      else
-        raise_sema_error("unsupported foreign passing mode #{parameter.passing_mode}")
       end
-    end
 
-    def foreign_consuming_argument_binding(parameter, argument, scopes:, function_name:)
-      unless argument.value.is_a?(AST::Identifier)
-        raise_sema_error("consuming argument #{parameter.name} to #{function_name} must be a bare nullable local or parameter binding")
+      def foreign_argument_legacy_passing_mode(argument)
+        return nil unless argument.value.is_a?(AST::UnaryOp) && ["out", "in", "inout"].include?(argument.value.operator)
+
+        argument.value.operator
       end
 
-      binding = lookup_value(argument.value.name, scopes)
-      unless binding && %i[let var param].include?(binding.kind) && binding.storage_type.is_a?(Types::Nullable) && binding.storage_type.base == parameter.type
-        raise_sema_error("consuming argument #{parameter.name} to #{function_name} must be a bare nullable local or parameter binding")
+      def foreign_argument_actual_type(parameter, argument, scopes:, function_name:, expected_type: parameter.type)
+        case parameter.passing_mode
+        when :plain
+          infer_expression(argument.value, scopes:, expected_type:)
+        when :consuming
+          foreign_consuming_argument_binding(parameter, argument, scopes:, function_name:)
+          parameter.type
+        when :in, :out, :inout
+          if (legacy_passing_mode = foreign_argument_legacy_passing_mode(argument))
+            raise_sema_error("argument #{parameter.name} to #{function_name} must not use #{legacy_passing_mode}; directional passing is declared on #{function_name}")
+          end
+
+          if parameter.passing_mode == :in
+            infer_expression(argument.value, scopes:, expected_type: expected_type)
+          else
+            infer_lvalue(argument.value, scopes:)
+          end
+        else
+          raise_sema_error("unsupported foreign passing mode #{parameter.passing_mode}")
+        end
       end
 
-      binding
+      def foreign_consuming_argument_binding(parameter, argument, scopes:, function_name:)
+        unless argument.value.is_a?(AST::Identifier)
+          raise_sema_error("consuming argument #{parameter.name} to #{function_name} must be a bare nullable local or parameter binding")
+        end
+
+        binding = lookup_value(argument.value.name, scopes)
+        unless binding && %i[let var param].include?(binding.kind) && binding.storage_type.is_a?(Types::Nullable) && binding.storage_type.base == parameter.type
+          raise_sema_error("consuming argument #{parameter.name} to #{function_name} must be a bare nullable local or parameter binding")
+        end
+
+        binding
+      end
     end
+
   end
 end