mt-lang 0.2.0

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

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class SemanticAnalyzer
+    class Checker
+      private
+
+      def current_actual_scope(scopes)
+        scopes.reverse_each do |scope|
+          return scope unless scope.is_a?(FlowScope)
+        end
+
+        raise_sema_error("missing lexical scope")
+      end
+
+      def apply_continuation_refinements!(scopes, refinements)
+        return if refinements.nil? || refinements.empty?
+
+        scopes.replace(scopes_with_refinements(scopes, refinements))
+      end
+
+      def scopes_with_refinements(scopes, refinements)
+        return scopes if refinements.nil? || refinements.empty?
+
+        base_scopes = scopes.last.is_a?(FlowScope) ? scopes[0...-1] : scopes
+        merged_refinements = if scopes.last.is_a?(FlowScope)
+                               scopes.last.each_with_object({}) do |(name, binding), result|
+                                 result[name] = if name.is_a?(String) && binding.respond_to?(:type)
+                                                  binding.type
+                                                else
+                                                  binding
+                                                end
+                               end
+                             else
+                               {}
+                             end
+        merged_refinements = merge_refinements(merged_refinements, refinements)
+        flow_scope = FlowScope.new
+
+        merged_refinements.each do |name, refined_type|
+          unless name.is_a?(String)
+            flow_scope[name] = refined_type
+            next
+          end
+
+          binding = lookup_value(name, base_scopes)
+          next unless binding
+
+          flow_scope[name] = binding.with_flow_type(refined_type)
+        end
+
+        return base_scopes if flow_scope.empty?
+
+        base_scopes + [flow_scope]
+      end
+
+      def merge_refinements(existing, incoming)
+        merged = existing.dup
+        incoming.each do |name, refined_type|
+          if merged.key?(name) && merged[name] != refined_type
+            merged.delete(name)
+          else
+            merged[name] = refined_type
+          end
+        end
+
+        merged
+      end
+
+      def flow_refinements(expression, truthy:, scopes:)
+        case expression
+        when AST::Call
+          if truthy && has_attribute_refinement_call?(expression)
+            key = attribute_presence_key_from_call(expression, scopes:)
+            return key ? { key => true } : {}
+          end
+        when AST::UnaryOp
+          return flow_refinements(expression.operand, truthy: !truthy, scopes:) if expression.operator == "not"
+        when AST::BinaryOp
+          case expression.operator
+          when "and"
+            if truthy
+              left_truthy = flow_refinements(expression.left, truthy: true, scopes:)
+              right_scopes = scopes_with_refinements(scopes, left_truthy)
+              right_truthy = flow_refinements(expression.right, truthy: true, scopes: right_scopes)
+              return merge_refinements(left_truthy, right_truthy)
+            end
+          when "or"
+            unless truthy
+              left_falsy = flow_refinements(expression.left, truthy: false, scopes:)
+              right_scopes = scopes_with_refinements(scopes, left_falsy)
+              right_falsy = flow_refinements(expression.right, truthy: false, scopes: right_scopes)
+              return merge_refinements(left_falsy, right_falsy)
+            end
+          when "==", "!="
+            return null_test_refinements(expression, truthy:, scopes:)
+          end
+        end
+
+        {}
+      end
+
+      def start_local_completion_frame(binding, scopes)
+        frame = {
+          function_name: binding.name,
+          receiver_type: binding.type.receiver_type,
+          snapshots: [],
+        }
+        @active_local_completion_stack << frame
+        record_local_completion_snapshot(binding.ast.respond_to?(:line) ? binding.ast.line : nil, 0, scopes)
+      end
+
+      def finish_local_completion_frame(binding)
+        return if @active_local_completion_stack.empty?
+
+        frame = @active_local_completion_stack.pop
+        snapshots = frame[:snapshots]
+        if snapshots.empty?
+          return
+        end
+
+        start_line = [binding.ast.respond_to?(:line) ? binding.ast.line : nil, snapshots.first.line].compact.min
+        end_line = snapshots.last.line
+
+        @local_completion_frames << LocalCompletionFrame.new(
+          start_line:,
+          end_line:,
+          function_name: frame[:function_name],
+          receiver_type: frame[:receiver_type],
+          snapshots: snapshots.freeze,
+        )
+      end
+
+      def record_local_completion_snapshot(line, column, scopes)
+        return if @active_local_completion_stack.empty?
+        return if line.nil?
+
+        snapshot = LocalCompletionSnapshot.new(
+          line:,
+          column: (column || 0),
+          bindings: merged_scope_bindings(scopes).freeze,
+        )
+
+        snapshots = @active_local_completion_stack.last[:snapshots]
+        prev = snapshots.last
+        if prev && prev.line == snapshot.line && prev.column == snapshot.column
+          snapshots[-1] = snapshot
+        else
+          snapshots << snapshot
+        end
+      end
+
+      def merged_scope_bindings(scopes)
+        scopes.each_with_object({}) do |scope, bindings|
+          scope.each do |name, binding|
+            next unless name.is_a?(String)
+
+            bindings[name] = binding
+          end
+        end
+      end
+
+      def has_attribute_refinement_call?(expression)
+        expression.callee.is_a?(AST::Identifier) && expression.callee.name == "has_attribute" && expression.arguments.length == 2 && expression.arguments.none?(&:name)
+      end
+
+      def attribute_presence_key_from_call(expression, scopes:)
+        target = resolve_reflection_target_argument(expression.arguments.first.value, scopes:)
+        binding = resolve_attribute_name_argument(expression.arguments[1].value)
+        validate_attribute_target_compatibility!(target, binding)
+        attribute_presence_refinement_key(target, binding)
+      rescue SemanticError
+        nil
+      end
+
+      def statement_end_line(statement)
+        return nil unless statement
+
+        lines = [statement.respond_to?(:line) ? statement.line : nil]
+
+        case statement
+        when AST::ErrorBlockStmt
+          lines.concat(statement_list_lines(statement.body))
+        when AST::LocalDecl
+          lines << expression_end_line(statement.value) if statement.value
+          lines.concat(statement_list_lines(statement.else_body)) if statement.else_body
+        when AST::IfStmt
+          statement.branches.each do |branch|
+            lines << expression_end_line(branch.condition)
+            lines.concat(statement_list_lines(branch.body))
+          end
+          lines.concat(statement_list_lines(statement.else_body)) if statement.else_body
+        when AST::UnsafeStmt, AST::ForStmt, AST::WhileStmt
+          lines.concat(statement_list_lines(statement.body))
+        when AST::MatchStmt
+          statement.arms.each do |arm|
+            lines.concat(statement_list_lines(arm.body))
+          end
+        when AST::DeferStmt
+          lines.concat(statement_list_lines(statement.body)) if statement.body
+        when AST::Assignment
+          lines << expression_end_line(statement.value)
+        when AST::ReturnStmt
+          lines << expression_end_line(statement.value)
+        when AST::ExpressionStmt
+          lines << expression_end_line(statement.expression)
+        when AST::StaticAssert
+          lines << expression_end_line(statement.condition)
+        end
+
+        lines.compact.max
+      end
+
+      def statement_list_lines(statements)
+        return [] unless statements
+
+        statements.each_with_object([]) do |stmt, lines|
+          end_line = statement_end_line(stmt)
+          lines << end_line if end_line
+        end
+      end
+
+      def expression_end_line(node)
+        return nil unless node
+
+        lines = [node.respond_to?(:line) ? node.line : nil]
+
+        case node
+        when AST::MemberAccess
+          lines << expression_end_line(node.receiver)
+        when AST::IndexAccess
+          lines << expression_end_line(node.receiver)
+          lines << expression_end_line(node.index)
+        when AST::Specialization
+          lines << expression_end_line(node.callee)
+        when AST::Call
+          lines << expression_end_line(node.callee)
+          node.arguments.each { |argument| lines << expression_end_line(argument.value) }
+        when AST::Argument
+          lines << expression_end_line(node.value)
+        when AST::UnaryOp
+          lines << expression_end_line(node.operand)
+        when AST::BinaryOp
+          lines << expression_end_line(node.left)
+          lines << expression_end_line(node.right)
+        when AST::IfExpr
+          lines << expression_end_line(node.condition)
+          lines << expression_end_line(node.then_expression)
+          lines << expression_end_line(node.else_expression)
+        when AST::MatchExpr
+          lines << expression_end_line(node.expression)
+          node.arms.each do |arm|
+            lines << expression_end_line(arm.pattern)
+            lines << expression_end_line(arm.value)
+          end
+        when AST::AwaitExpr
+          lines << expression_end_line(node.expression)
+        when AST::FormatExprPart
+          lines << expression_end_line(node.expression)
+        when AST::PrefixCast
+          lines << expression_end_line(node.expression)
+        end
+
+        lines.compact.max
+      end
+
+      def recovered_for_statement(statement)
+        AST::ForStmt.new(
+          bindings: Array(statement.header_bindings),
+          iterables: Array(statement.header_iterables),
+          body: statement.body,
+          line: statement.line,
+          column: statement.column,
+        )
+      end
+
+      def null_test_refinements(expression, truthy:, scopes:)
+        identifier_expression = nil
+        if expression.left.is_a?(AST::Identifier) && expression.right.is_a?(AST::NullLiteral)
+          identifier_expression = expression.left
+        elsif expression.left.is_a?(AST::NullLiteral) && expression.right.is_a?(AST::Identifier)
+          identifier_expression = expression.right
+        else
+          return {}
+        end
+
+        binding = lookup_value(identifier_expression.name, scopes)
+        return {} unless binding&.storage_type.is_a?(Types::Nullable)
+
+        null_result = expression.operator == "==" ? truthy : !truthy
+        refined_type = null_result ? @null_type : binding.storage_type.base
+        { identifier_expression.name => refined_type }
+      end
+
+      def conditional_common_type(then_type, else_type, then_expression:, else_expression:)
+        return then_type if then_type == else_type
+
+        numeric_type = common_numeric_type(then_type, else_type)
+        return numeric_type if numeric_type
+
+        if (nullable_type = conditional_null_common_type(then_type, else_type))
+          return nullable_type
+        end
+
+        if (nullable_type = conditional_null_common_type(else_type, then_type))
+          return nullable_type
+        end
+
+        return then_type if types_compatible?(else_type, then_type, expression: else_expression)
+        return else_type if types_compatible?(then_type, else_type, expression: then_expression)
+
+        nil
+      end
+
+      def nullable_candidate?(type)
+        return false if ref_type?(type)
+
+        sized_layout_type?(type) || pointer_type?(type) || type.is_a?(Types::Nullable)
+      end
+
+      def conditional_null_common_type(null_type, other_type)
+        return unless null_type.is_a?(Types::Null)
+
+        if other_type.is_a?(Types::Nullable)
+          return other_type if null_type.target_type.nil? || null_type.target_type == other_type.base
+
+          return nil
+        end
+
+        return unless nullable_candidate?(other_type)
+        return if null_type.target_type && null_type.target_type != other_type
+
+        Types::Registry.nullable(other_type)
+      end
+
+      def describe_expression(expression)
+        case expression
+        when AST::Identifier
+          expression.name
+        when AST::MemberAccess
+          "#{describe_expression(expression.receiver)}.#{expression.member}"
+        when AST::IndexAccess
+          "#{describe_expression(expression.receiver)}[...]"
+        when AST::Specialization
+          "#{describe_expression(expression.callee)}[...]"
+        when AST::FormatString
+          'f"..."'
+        else
+          expression.class.name.split("::").last
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class SemanticAnalyzer::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")
+      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)
+
+      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
+
+    def foreign_cstr_boundary_parameter?(parameter)
+      parameter.boundary_type == @ctx.types.fetch("cstr") && parameter.type == @ctx.types.fetch("str")
+    end
+
+    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)
+
+      nil
+    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
+
+      public_type
+    end
+
+    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
+
+      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_mapping_public_alias_name(name)
+      "#{name}_public"
+    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)
+
+      raise_sema_error("foreign parameter #{parameter_name} of #{function_name} cannot map #{public_type} as #{boundary_type}")
+    end
+
+    def foreign_function_binding?(binding)
+      binding.ast.is_a?(AST::ForeignFunctionDecl)
+    end
+
+    def foreign_mapping_expression(decl)
+      return decl.mapping unless foreign_mapping_auto_call_shorthand?(decl.mapping)
+
+      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_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
+
+    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
+      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)
+
+      argument.value.operator
+    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}")
+        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
+
+    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