mt-lang 0.2.0

data/lib/milk_tea/core/lowering/scans.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LowererScans
+    private
+
+      def collect_structs
+        @ctx.ast.declarations.each do |decl|
+          case decl
+          when AST::WhenStmt
+            body = lower_when_chosen_body(decl)
+            body&.each { |nested| collect_struct_from_decl(nested) }
+          when AST::OpaqueDecl
+            @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
+          when AST::StructDecl
+            @ctx.struct_types[decl.name] = @ctx.types.fetch(decl.name)
+            collect_nested_structs(decl)
+          when AST::UnionDecl
+            @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
+          end
+        end
+      end
+
+      def collect_struct_from_decl(decl)
+        case decl
+        when AST::OpaqueDecl
+          @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
+        when AST::StructDecl
+          @ctx.struct_types[decl.name] = @ctx.types.fetch(decl.name)
+          collect_nested_structs(decl)
+        when AST::UnionDecl
+          @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
+        when AST::WhenStmt
+          body = lower_when_chosen_body(decl)
+          body&.each { |nested| collect_struct_from_decl(nested) }
+        end
+      end
+
+      def lower_when_chosen_body(decl)
+        val = compile_time_const_value(decl.discriminant)
+        return nil if val.nil?
+
+        chosen = decl.branches.find { |b| val == compile_time_const_value(b.pattern) }
+        chosen&.body || decl.else_body
+      end
+
+      def collect_nested_structs(parent_decl, parent_name: parent_decl.name)
+        parent_decl.nested_types.each do |nested|
+          qualified_name = "#{parent_name}.#{nested.name}"
+          @ctx.struct_types[qualified_name] = @ctx.types.fetch(qualified_name)
+          collect_nested_structs(nested, parent_name: qualified_name)
+        end
+      end
+
+      def collect_includes
+        headers = ["<stdbool.h>", "<stdint.h>", "<string.h>"]
+        headers << "<stddef.h>" if program_uses_offsetof?
+        headers << "<stdio.h>" if program_uses_fatal?
+
+        each_raw_module_analysis do |analysis|
+          analysis.directives.grep(AST::IncludeDirective).each do |directive|
+            headers << normalized_include_header(directive.value)
+          end
+        end
+
+        headers.uniq.map { |header| IR::Include.new(header:) }
+      end
+
+      def normalized_include_header(header_name)
+        return "<#{header_name}>" if standard_c_runtime_header?(header_name)
+
+        %("#{header_name}")
+      end
+
+      def standard_c_runtime_header?(header_name)
+        %w[stdbool.h stdint.h stdlib.h string.h stddef.h stdio.h time.h].include?(header_name)
+      end
+
+      def program_uses_fatal?
+        each_non_raw_module_analysis.any? do |analysis|
+          analysis_uses_fatal?(analysis)
+        end
+      end
+
+      def program_uses_offsetof?
+        each_non_raw_module_analysis.any? do |analysis|
+          analysis_uses_offsetof?(analysis)
+        end
+      end
+
+      def analysis_uses_fatal?(analysis)
+        analysis.ast.declarations.any? do |decl|
+          case decl
+          when AST::FunctionDef
+            block_uses_fatal?(decl.body)
+          when AST::ExtendingBlock
+            decl.methods.any? { |method| block_uses_fatal?(method.body) }
+          else
+            false
+          end
+        end
+      end
+
+      def analysis_uses_offsetof?(analysis)
+        analysis.ast.declarations.any? do |decl|
+          case decl
+          when AST::FunctionDef
+            block_uses_offsetof?(decl.body)
+          when AST::ExtendingBlock
+            decl.methods.any? { |method| block_uses_offsetof?(method.body) }
+          else
+            false
+          end
+        end
+      end
+
+      def block_uses_fatal?(statements)
+        block_uses_expression_pattern?(statements) { |expression| fatal_expression?(expression) }
+      end
+
+      def block_uses_offsetof?(statements)
+        block_uses_expression_pattern?(statements) { |expression| offsetof_expression?(expression) }
+      end
+
+      def block_uses_expression_pattern?(statements, &predicate)
+        statements.any? { |statement| statement_uses_expression_pattern?(statement, &predicate) }
+      end
+
+      def statement_uses_expression_pattern?(statement, &predicate)
+        case statement
+        when AST::LocalDecl
+          expression_uses_pattern?(statement.value, &predicate)
+        when AST::Assignment
+          expression_uses_pattern?(statement.target, &predicate) || expression_uses_pattern?(statement.value, &predicate)
+        when AST::IfStmt
+          statement.branches.any? { |branch| expression_uses_pattern?(branch.condition, &predicate) || block_uses_expression_pattern?(branch.body, &predicate) } ||
+            (statement.else_body && block_uses_expression_pattern?(statement.else_body, &predicate))
+        when AST::MatchStmt
+          expression_uses_pattern?(statement.expression, &predicate) || statement.arms.any? { |arm| expression_uses_pattern?(arm.pattern, &predicate) || block_uses_expression_pattern?(arm.body, &predicate) }
+        when AST::StaticAssert
+          expression_uses_pattern?(statement.condition, &predicate) || expression_uses_pattern?(statement.message, &predicate)
+        when AST::ForStmt
+          statement.iterables.any? { |iterable| expression_uses_pattern?(iterable, &predicate) } || block_uses_expression_pattern?(statement.body, &predicate)
+        when AST::UnsafeStmt, AST::WhileStmt
+          expression = statement.is_a?(AST::WhileStmt) ? statement.condition : nil
+          (expression && expression_uses_pattern?(expression, &predicate)) || block_uses_expression_pattern?(statement.body, &predicate)
+        when AST::ReturnStmt
+          statement.value && expression_uses_pattern?(statement.value, &predicate)
+        when AST::DeferStmt, AST::ExpressionStmt
+          expression_uses_pattern?(statement.expression, &predicate)
+        else
+          false
+        end
+      end
+
+      def fatal_expression?(expression)
+        expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
+      end
+
+      def offsetof_expression?(expression)
+        expression.is_a?(AST::OffsetofExpr)
+      end
+
+      def expression_uses_pattern?(expression, &predicate)
+        return false unless expression
+        return true if predicate.call(expression)
+
+        case expression
+        when AST::AwaitExpr
+          expression_uses_pattern?(expression.expression, &predicate)
+        when AST::Call
+          expression_uses_pattern?(expression.callee, &predicate) || expression.arguments.any? { |argument| expression_uses_pattern?(argument.value, &predicate) }
+        when AST::BinaryOp
+          expression_uses_pattern?(expression.left, &predicate) || expression_uses_pattern?(expression.right, &predicate)
+        when AST::RangeExpr
+          expression_uses_pattern?(expression.start_expr, &predicate) || expression_uses_pattern?(expression.end_expr, &predicate)
+        when AST::IfExpr
+          expression_uses_pattern?(expression.condition, &predicate) || expression_uses_pattern?(expression.then_expression, &predicate) || expression_uses_pattern?(expression.else_expression, &predicate)
+        when AST::MatchExpr
+          expression_uses_pattern?(expression.expression, &predicate) || expression.arms.any? { |arm| expression_uses_pattern?(arm.pattern, &predicate) || expression_uses_pattern?(arm.value, &predicate) }
+        when AST::UnsafeExpr
+          expression_uses_pattern?(expression.expression, &predicate)
+        when AST::PrefixCast
+          expression_uses_pattern?(expression.expression, &predicate)
+        when AST::UnaryOp
+          expression_uses_pattern?(expression.operand, &predicate)
+        when AST::MemberAccess
+          expression_uses_pattern?(expression.receiver, &predicate)
+        when AST::IndexAccess
+          expression_uses_pattern?(expression.receiver, &predicate) || expression_uses_pattern?(expression.index, &predicate)
+        when AST::Specialization
+          expression_uses_pattern?(expression.callee, &predicate) || expression.arguments.any? { |argument| expression_uses_pattern?(argument.value, &predicate) }
+        else
+          false
+        end
+      end
+
+      def prepare_analysis(analysis, source_path: nil)
+        @ctx.install(analysis)
+        @ctx.current_analysis_path = source_path
+        @ctx.module_prefix = module_c_prefix(@ctx.module_name)
+      end
+
+      private def sanitize_type_name_for_tuple(type)
+        type.to_s.gsub(/[^a-zA-Z0-9]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
+      end
+
+      def build_method_definitions
+        @program.analyses_by_path.values.each_with_object({}) do |analysis, definitions|
+          analysis.ast.declarations.grep(AST::ExtendingBlock).each do |extending_block|
+            receiver_type = resolve_extending_receiver_type(analysis, extending_block.type_name)
+            extending_block.methods.each do |method|
+              method_key = method.kind == :static ? "static:#{method.name}" : method.name
+              definitions[[receiver_type, method_key]] = [analysis, method]
+            end
+          end
+        end
+      end
+  end
+end

data/lib/milk_tea/core/lowering/str_buffer.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LowererStrBuffer
+    private
+
+
+      def str_buffer_method_kind(receiver_type, name)
+        return unless str_buffer_type?(receiver_type)
+
+        case name
+        when "clear"
+          :str_buffer_clear
+        when "assign"
+          :str_buffer_assign
+        when "append"
+          :str_buffer_append
+        when "assign_format"
+          :str_buffer_assign_format
+        when "append_format"
+          :str_buffer_append_format
+        when "len"
+          :str_buffer_len
+        when "capacity"
+          :str_buffer_capacity
+        when "as_str"
+          :str_buffer_as_str
+        when "as_cstr"
+          :str_buffer_as_cstr
+        end
+      end
+
+      def str_buffer_method_type(kind, receiver_type)
+        return_type, params = case kind
+                              when :str_buffer_clear
+                                [@ctx.types.fetch("void"), []]
+                              when :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format
+                                [@ctx.types.fetch("void"), [Types::Registry.parameter("value", @ctx.types.fetch("str"))]]
+                              when :str_buffer_len, :str_buffer_capacity
+                                [@ctx.types.fetch("ptr_uint"), []]
+                              when :str_buffer_as_str
+                                [@ctx.types.fetch("str"), []]
+                              when :str_buffer_as_cstr
+                                [@ctx.types.fetch("cstr"), []]
+                              else
+                                raise LoweringError, "unsupported str_buffer method #{kind}"
+                              end
+
+        Types::Registry.function(
+          kind.to_s,
+          params:,
+          return_type:,
+          receiver_type:,
+          receiver_editable: %i[str_buffer_clear str_buffer_assign str_buffer_append str_buffer_assign_format str_buffer_append_format].include?(kind),
+          external: false,
+        )
+      end
+
+      def lower_char_array_data_pointer(expression, env:)
+        lowered_receiver = lower_expression(expression, env:)
+        IR::AddressOf.new(
+          expression: IR::Index.new(
+            receiver: lowered_receiver,
+            index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
+            type: @ctx.types.fetch("char"),
+          ),
+          type: pointer_to(@ctx.types.fetch("char")),
+        )
+      end
+
+      def lower_str_buffer_data_pointer(expression, env:)
+        lower_str_buffer_data_pointer_from_lowered(lower_expression(expression, env:))
+      end
+
+      def lower_str_buffer_data_pointer_from_lowered(lowered_receiver)
+        IR::AddressOf.new(
+          expression: IR::Index.new(
+            receiver: IR::Member.new(
+              receiver: lowered_receiver,
+              member: "data",
+              type: Types::Registry.generic_instance(
+                "array",
+                [@ctx.types.fetch("char"), Types::LiteralTypeArg.new(str_buffer_storage_capacity(lowered_receiver.type))],
+              ),
+            ),
+            index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
+            type: @ctx.types.fetch("char"),
+          ),
+          type: pointer_to(@ctx.types.fetch("char")),
+        )
+      end
+
+      def lower_str_buffer_len_pointer(expression, env:)
+        lower_str_buffer_len_pointer_from_lowered(lower_expression(expression, env:))
+      end
+
+      def lower_str_buffer_len_pointer_from_lowered(lowered_receiver)
+        IR::AddressOf.new(
+          expression: IR::Member.new(receiver: lowered_receiver, member: "len", type: @ctx.types.fetch("ptr_uint")),
+          type: pointer_to(@ctx.types.fetch("ptr_uint")),
+        )
+      end
+
+      def lower_str_buffer_dirty_pointer(expression, env:)
+        lower_str_buffer_dirty_pointer_from_lowered(lower_expression(expression, env:))
+      end
+
+      def lower_str_buffer_dirty_pointer_from_lowered(lowered_receiver)
+        IR::AddressOf.new(
+          expression: IR::Member.new(receiver: lowered_receiver, member: "dirty", type: @ctx.types.fetch("bool")),
+          type: pointer_to(@ctx.types.fetch("bool")),
+        )
+      end
+
+      def str_buffer_args(receiver, env:)
+        receiver_type = infer_expression_type(receiver, env:)
+        [
+          lower_str_buffer_data_pointer(receiver, env:),
+          IR::IntegerLiteral.new(value: str_buffer_capacity(receiver_type), type: @ctx.types.fetch("ptr_uint")),
+          lower_str_buffer_len_pointer(receiver, env:),
+          lower_str_buffer_dirty_pointer(receiver, env:),
+        ]
+      end
+  end
+end