mt-lang 0.3.4 → 0.3.6

data/lib/milk_tea/core/c_backend/type_collectors.rb

@@ -483,45 +483,52 @@ module MilkTea
             proc_types
           end
 
-          def collect_proc_types_from_statements(statements, proc_types, visited)
-            statements.each do |statement|
-              case statement
+          def each_ir_statement_for_type_collection(statements, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+            statements.each do |stmt|
+              case stmt
               when IR::LocalDecl
-                collect_proc_type(statement.type, proc_types, visited)
-                collect_proc_types_from_expression(statement.value, proc_types, visited)
+                send(type_collector_method, stmt.type, accumulator, visited)
+                send(expression_walker_method, stmt.value, accumulator, visited) if stmt.value
               when IR::Assignment
-                collect_proc_types_from_expression(statement.target, proc_types, visited)
-                collect_proc_types_from_expression(statement.value, proc_types, visited)
+                send(expression_walker_method, stmt.target, accumulator, visited)
+                send(expression_walker_method, stmt.value, accumulator, visited)
               when IR::BlockStmt
-                collect_proc_types_from_statements(statement.body, proc_types, visited)
+                each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
               when IR::WhileStmt
-                collect_proc_types_from_expression(statement.condition, proc_types, visited)
-                collect_proc_types_from_statements(statement.body, proc_types, visited)
+                send(expression_walker_method, stmt.condition, accumulator, visited)
+                each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
               when IR::ForStmt
-                collect_proc_types_from_statements([statement.init], proc_types, visited)
-                collect_proc_types_from_expression(statement.condition, proc_types, visited)
-                collect_proc_types_from_statements(statement.body, proc_types, visited)
-                collect_proc_types_from_statements([statement.post], proc_types, visited)
+                each_ir_statement_for_type_collection([stmt.init], type_collector_method:, expression_walker_method:, accumulator:, visited:)
+                send(expression_walker_method, stmt.condition, accumulator, visited)
+                each_ir_statement_for_type_collection(stmt.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+                each_ir_statement_for_type_collection([stmt.post], type_collector_method:, expression_walker_method:, accumulator:, visited:)
               when IR::IfStmt
-                collect_proc_types_from_expression(statement.condition, proc_types, visited)
-                collect_proc_types_from_statements(statement.then_body, proc_types, visited)
-                collect_proc_types_from_statements(statement.else_body, proc_types, visited) if statement.else_body
+                send(expression_walker_method, stmt.condition, accumulator, visited)
+                each_ir_statement_for_type_collection(stmt.then_body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
+                each_ir_statement_for_type_collection(stmt.else_body, type_collector_method:, expression_walker_method:, accumulator:, visited:) if stmt.else_body
               when IR::SwitchStmt
-                collect_proc_types_from_expression(statement.expression, proc_types, visited)
-                statement.cases.each do |switch_case|
-                  collect_proc_types_from_statements(switch_case.body, proc_types, visited)
+                send(expression_walker_method, stmt.expression, accumulator, visited)
+                stmt.cases.each do |switch_case|
+                  each_ir_statement_for_type_collection(switch_case.body, type_collector_method:, expression_walker_method:, accumulator:, visited:)
                 end
               when IR::StaticAssert
-                collect_proc_types_from_expression(statement.condition, proc_types, visited)
-                collect_proc_types_from_expression(statement.message, proc_types, visited)
+                send(expression_walker_method, stmt.condition, accumulator, visited)
+                send(expression_walker_method, stmt.message, accumulator, visited)
               when IR::ReturnStmt
-                collect_proc_types_from_expression(statement.value, proc_types, visited) if statement.value
+                send(expression_walker_method, stmt.value, accumulator, visited) if stmt.value
               when IR::ExpressionStmt
-                collect_proc_types_from_expression(statement.expression, proc_types, visited)
+                send(expression_walker_method, stmt.expression, accumulator, visited)
               end
             end
           end
 
+          def collect_proc_types_from_statements(statements, proc_types, visited)
+            each_ir_statement_for_type_collection(statements,
+              type_collector_method: :collect_proc_type,
+              expression_walker_method: :collect_proc_types_from_expression,
+              accumulator: proc_types, visited:)
+          end
+
           def collect_proc_types_from_expression(expression, proc_types, visited)
             case expression
             when IR::Member
@@ -610,42 +617,10 @@ module MilkTea
           end
 
           def collect_task_types_from_statements(statements, task_types, visited)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_task_type(statement.type, task_types, visited)
-                collect_task_types_from_expression(statement.value, task_types, visited)
-              when IR::Assignment
-                collect_task_types_from_expression(statement.target, task_types, visited)
-                collect_task_types_from_expression(statement.value, task_types, visited)
-              when IR::BlockStmt
-                collect_task_types_from_statements(statement.body, task_types, visited)
-              when IR::WhileStmt
-                collect_task_types_from_expression(statement.condition, task_types, visited)
-                collect_task_types_from_statements(statement.body, task_types, visited)
-              when IR::ForStmt
-                collect_task_types_from_statements([statement.init], task_types, visited)
-                collect_task_types_from_expression(statement.condition, task_types, visited)
-                collect_task_types_from_statements(statement.body, task_types, visited)
-                collect_task_types_from_statements([statement.post], task_types, visited)
-              when IR::IfStmt
-                collect_task_types_from_expression(statement.condition, task_types, visited)
-                collect_task_types_from_statements(statement.then_body, task_types, visited)
-                collect_task_types_from_statements(statement.else_body, task_types, visited) if statement.else_body
-              when IR::SwitchStmt
-                collect_task_types_from_expression(statement.expression, task_types, visited)
-                statement.cases.each do |switch_case|
-                  collect_task_types_from_statements(switch_case.body, task_types, visited)
-                end
-              when IR::StaticAssert
-                collect_task_types_from_expression(statement.condition, task_types, visited)
-                collect_task_types_from_expression(statement.message, task_types, visited)
-              when IR::ReturnStmt
-                collect_task_types_from_expression(statement.value, task_types, visited) if statement.value
-              when IR::ExpressionStmt
-                collect_task_types_from_expression(statement.expression, task_types, visited)
-              end
-            end
+            each_ir_statement_for_type_collection(statements,
+              type_collector_method: :collect_task_type,
+              expression_walker_method: :collect_task_types_from_expression,
+              accumulator: task_types, visited:)
           end
 
           def collect_task_types_from_expression(expression, task_types, visited)
@@ -771,42 +746,10 @@ module MilkTea
           end
 
           def collect_generic_variant_types_from_statements(statements, generic_variant_types, visited)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_generic_variant_type(statement.type, generic_variant_types, visited)
-                collect_generic_variant_types_from_expression(statement.value, generic_variant_types, visited)
-              when IR::Assignment
-                collect_generic_variant_types_from_expression(statement.target, generic_variant_types, visited)
-                collect_generic_variant_types_from_expression(statement.value, generic_variant_types, visited)
-              when IR::BlockStmt
-                collect_generic_variant_types_from_statements(statement.body, generic_variant_types, visited)
-              when IR::WhileStmt
-                collect_generic_variant_types_from_expression(statement.condition, generic_variant_types, visited)
-                collect_generic_variant_types_from_statements(statement.body, generic_variant_types, visited)
-              when IR::ForStmt
-                collect_generic_variant_types_from_statements([statement.init], generic_variant_types, visited)
-                collect_generic_variant_types_from_expression(statement.condition, generic_variant_types, visited)
-                collect_generic_variant_types_from_statements(statement.body, generic_variant_types, visited)
-                collect_generic_variant_types_from_statements([statement.post], generic_variant_types, visited)
-              when IR::IfStmt
-                collect_generic_variant_types_from_expression(statement.condition, generic_variant_types, visited)
-                collect_generic_variant_types_from_statements(statement.then_body, generic_variant_types, visited)
-                collect_generic_variant_types_from_statements(statement.else_body, generic_variant_types, visited) if statement.else_body
-              when IR::SwitchStmt
-                collect_generic_variant_types_from_expression(statement.expression, generic_variant_types, visited)
-                statement.cases.each do |switch_case|
-                  collect_generic_variant_types_from_statements(switch_case.body, generic_variant_types, visited)
-                end
-              when IR::StaticAssert
-                collect_generic_variant_types_from_expression(statement.condition, generic_variant_types, visited)
-                collect_generic_variant_types_from_expression(statement.message, generic_variant_types, visited)
-              when IR::ReturnStmt
-                collect_generic_variant_types_from_expression(statement.value, generic_variant_types, visited) if statement.value
-              when IR::ExpressionStmt
-                collect_generic_variant_types_from_expression(statement.expression, generic_variant_types, visited)
-              end
-            end
+            each_ir_statement_for_type_collection(statements,
+              type_collector_method: :collect_generic_variant_type,
+              expression_walker_method: :collect_generic_variant_types_from_expression,
+              accumulator: generic_variant_types, visited:)
           end
 
           def collect_generic_variant_types_from_expression(expression, generic_variant_types, visited)
@@ -981,42 +924,10 @@ module MilkTea
           end
 
           def collect_str_buffer_types_from_statements(statements, str_buffer_types, visited)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_str_buffer_type(statement.type, str_buffer_types, visited)
-                collect_str_buffer_types_from_expression(statement.value, str_buffer_types, visited)
-              when IR::Assignment
-                collect_str_buffer_types_from_expression(statement.target, str_buffer_types, visited)
-                collect_str_buffer_types_from_expression(statement.value, str_buffer_types, visited)
-              when IR::BlockStmt
-                collect_str_buffer_types_from_statements(statement.body, str_buffer_types, visited)
-              when IR::WhileStmt
-                collect_str_buffer_types_from_expression(statement.condition, str_buffer_types, visited)
-                collect_str_buffer_types_from_statements(statement.body, str_buffer_types, visited)
-              when IR::ForStmt
-                collect_str_buffer_types_from_statements([statement.init], str_buffer_types, visited)
-                collect_str_buffer_types_from_expression(statement.condition, str_buffer_types, visited)
-                collect_str_buffer_types_from_statements(statement.body, str_buffer_types, visited)
-                collect_str_buffer_types_from_statements([statement.post], str_buffer_types, visited)
-              when IR::IfStmt
-                collect_str_buffer_types_from_expression(statement.condition, str_buffer_types, visited)
-                collect_str_buffer_types_from_statements(statement.then_body, str_buffer_types, visited)
-                collect_str_buffer_types_from_statements(statement.else_body, str_buffer_types, visited) if statement.else_body
-              when IR::SwitchStmt
-                collect_str_buffer_types_from_expression(statement.expression, str_buffer_types, visited)
-                statement.cases.each do |switch_case|
-                  collect_str_buffer_types_from_statements(switch_case.body, str_buffer_types, visited)
-                end
-              when IR::StaticAssert
-                collect_str_buffer_types_from_expression(statement.condition, str_buffer_types, visited)
-                collect_str_buffer_types_from_expression(statement.message, str_buffer_types, visited)
-              when IR::ReturnStmt
-                collect_str_buffer_types_from_expression(statement.value, str_buffer_types, visited) if statement.value
-              when IR::ExpressionStmt
-                collect_str_buffer_types_from_expression(statement.expression, str_buffer_types, visited)
-              end
-            end
+            each_ir_statement_for_type_collection(statements,
+              type_collector_method: :collect_str_buffer_type,
+              expression_walker_method: :collect_str_buffer_types_from_expression,
+              accumulator: str_buffer_types, visited:)
           end
 
           def collect_str_buffer_types_from_expression(expression, str_buffer_types, visited)
@@ -1100,42 +1011,10 @@ module MilkTea
           end
 
           def collect_generic_struct_types_from_statements(statements, generic_struct_types, visited)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_generic_struct_type(statement.type, generic_struct_types, visited)
-                collect_generic_struct_types_from_expression(statement.value, generic_struct_types, visited)
-              when IR::Assignment
-                collect_generic_struct_types_from_expression(statement.target, generic_struct_types, visited)
-                collect_generic_struct_types_from_expression(statement.value, generic_struct_types, visited)
-              when IR::BlockStmt
-                collect_generic_struct_types_from_statements(statement.body, generic_struct_types, visited)
-              when IR::WhileStmt
-                collect_generic_struct_types_from_expression(statement.condition, generic_struct_types, visited)
-                collect_generic_struct_types_from_statements(statement.body, generic_struct_types, visited)
-              when IR::ForStmt
-                collect_generic_struct_types_from_statements([statement.init], generic_struct_types, visited)
-                collect_generic_struct_types_from_expression(statement.condition, generic_struct_types, visited)
-                collect_generic_struct_types_from_statements(statement.body, generic_struct_types, visited)
-                collect_generic_struct_types_from_statements([statement.post], generic_struct_types, visited)
-              when IR::IfStmt
-                collect_generic_struct_types_from_expression(statement.condition, generic_struct_types, visited)
-                collect_generic_struct_types_from_statements(statement.then_body, generic_struct_types, visited)
-                collect_generic_struct_types_from_statements(statement.else_body, generic_struct_types, visited) if statement.else_body
-              when IR::SwitchStmt
-                collect_generic_struct_types_from_expression(statement.expression, generic_struct_types, visited)
-                statement.cases.each do |switch_case|
-                  collect_generic_struct_types_from_statements(switch_case.body, generic_struct_types, visited)
-                end
-              when IR::StaticAssert
-                collect_generic_struct_types_from_expression(statement.condition, generic_struct_types, visited)
-                collect_generic_struct_types_from_expression(statement.message, generic_struct_types, visited)
-              when IR::ReturnStmt
-                collect_generic_struct_types_from_expression(statement.value, generic_struct_types, visited) if statement.value
-              when IR::ExpressionStmt
-                collect_generic_struct_types_from_expression(statement.expression, generic_struct_types, visited)
-              end
-            end
+            each_ir_statement_for_type_collection(statements,
+              type_collector_method: :collect_generic_struct_type,
+              expression_walker_method: :collect_generic_struct_types_from_expression,
+              accumulator: generic_struct_types, visited:)
           end
 
           def collect_generic_struct_types_from_expression(expression, generic_struct_types, visited)
@@ -1221,42 +1100,10 @@ module MilkTea
           end
 
           def collect_span_types_from_statements(statements, span_types, visited)
-            statements.each do |statement|
-              case statement
-              when IR::LocalDecl
-                collect_span_type(statement.type, span_types, visited)
-                collect_span_types_from_expression(statement.value, span_types, visited)
-              when IR::Assignment
-                collect_span_types_from_expression(statement.target, span_types, visited)
-                collect_span_types_from_expression(statement.value, span_types, visited)
-              when IR::BlockStmt
-                collect_span_types_from_statements(statement.body, span_types, visited)
-              when IR::WhileStmt
-                collect_span_types_from_expression(statement.condition, span_types, visited)
-                collect_span_types_from_statements(statement.body, span_types, visited)
-              when IR::ForStmt
-                collect_span_types_from_statements([statement.init], span_types, visited)
-                collect_span_types_from_expression(statement.condition, span_types, visited)
-                collect_span_types_from_statements(statement.body, span_types, visited)
-                collect_span_types_from_statements([statement.post], span_types, visited)
-              when IR::IfStmt
-                collect_span_types_from_expression(statement.condition, span_types, visited)
-                collect_span_types_from_statements(statement.then_body, span_types, visited)
-                collect_span_types_from_statements(statement.else_body, span_types, visited) if statement.else_body
-              when IR::SwitchStmt
-                collect_span_types_from_expression(statement.expression, span_types, visited)
-                statement.cases.each do |switch_case|
-                  collect_span_types_from_statements(switch_case.body, span_types, visited)
-                end
-              when IR::StaticAssert
-                collect_span_types_from_expression(statement.condition, span_types, visited)
-                collect_span_types_from_expression(statement.message, span_types, visited)
-              when IR::ReturnStmt
-                collect_span_types_from_expression(statement.value, span_types, visited) if statement.value
-              when IR::ExpressionStmt
-                collect_span_types_from_expression(statement.expression, span_types, visited)
-              end
-            end
+            each_ir_statement_for_type_collection(statements,
+              type_collector_method: :collect_span_type,
+              expression_walker_method: :collect_span_types_from_expression,
+              accumulator: span_types, visited:)
           end
 
           def collect_span_types_from_expression(expression, span_types, visited)

data/lib/milk_tea/core/c_backend.rb

@@ -10,6 +10,7 @@ require_relative "c_backend/control_flow_emission"
 require_relative "c_backend/runtime_helpers"
 require_relative "c_backend/type_declaration"
 require_relative "c_backend/expressions"
+require_relative "c_backend/format_helpers"
 require_relative "c_backend/reinterpret"
 
 module MilkTea
@@ -54,6 +55,8 @@ module MilkTea
       @checked_index_alias_id = 0
       @loop_guard_id = 0
       @emitted_span_type_names = Set.new
+      @source_path = program.source_path
+      @current_line = nil
     end
 
     def emit
@@ -217,10 +220,16 @@ module MilkTea
       end
 
       constants.each do |constant|
+        @current_line = constant.line if constant.line
+        @source_path ||= constant.source_path if constant.source_path
         lines << "#{constant_storage(constant.type)} #{c_declaration(constant.type, constant.linkage_name)} = #{emit_initializer(constant.value)};"
       end
       @program.globals.each do |global|
         next unless emitted_globals.include?(global)
+        if global.respond_to?(:line) && global.line
+          @current_line = global.line
+          @source_path ||= global.source_path if global.respond_to?(:source_path) && global.source_path
+        end
         lines << "#{global_storage(global.type)} #{c_declaration(global.type, global.linkage_name)} = #{emit_initializer(global.value)};"
       end
       lines << "" unless constants.empty? && @program.globals.empty?
@@ -288,6 +297,7 @@ module MilkTea
     include Statements
     include ControlFlowEmission
     include RuntimeHelpers
+    include FormatHelpers
     include TypeDeclaration
     include Expressions
     include Reinterpret

data/lib/milk_tea/core/compatibility_helpers.rb

@@ -4,7 +4,7 @@ require_relative "types/predicates"
 
 module MilkTea
   module CompatibilityHelpers
-    include TypePredicates
+    include Types::Predicates
 
     BUILTIN_CSTR = Types::Registry.primitive("cstr")
 

data/lib/milk_tea/core/compile_time.rb

@@ -114,7 +114,12 @@ module MilkTea
                        else
                          @checker.instance_variable_get(:@ctx).types
                        end
-              if (type = types[call_expr.callee.name]) && type.is_a?(Types::Struct)
+              callee_name = if call_expr.callee.is_a?(AST::Specialization) && call_expr.callee.callee.respond_to?(:name)
+                              call_expr.callee.callee.name
+                            elsif call_expr.callee.respond_to?(:name)
+                              call_expr.callee.name
+                            end
+              if callee_name && (type = types[callee_name]) && type.is_a?(Types::Struct)
                 fields = {}
                 call_expr.arguments.each do |argument|
                   val = evaluate_expression(argument.value, scopes:)
@@ -123,6 +128,19 @@ module MilkTea
                 end
                 next fields
               end
+
+              if call_expr.callee.is_a?(AST::Specialization) && @checker.respond_to?(:resolve_type_expression)
+                resolved = @checker.send(:resolve_type_expression, call_expr.callee)
+                if resolved && @checker.respond_to?(:array_type?) && @checker.send(:array_type?, resolved)
+                  values = []
+                  call_expr.arguments.each do |argument|
+                    val = evaluate_expression(argument.value, scopes:)
+                    return nil unless val
+                    values << val
+                  end
+                  next values
+                end
+              end
               
               @checker.send(:evaluate_compile_time_const_value, call_expr, scopes:)
             },

data/lib/milk_tea/core/ir.rb

@@ -6,7 +6,9 @@ module MilkTea
       def initialize(module_name:, includes:, constants:, globals:, opaques:, structs:, unions:, enums:, variants:, static_asserts:, functions:, source_path: nil) = super
     end
     Include = Data.define(:header)
-    Constant = Data.define(:name, :linkage_name, :type, :value)
+    Constant = Data.define(:name, :linkage_name, :type, :value, :line, :source_path) do
+      def initialize(name:, linkage_name:, type:, value:, line: nil, source_path: nil) = super
+    end
     Global = Data.define(:name, :linkage_name, :type, :value)
     OpaqueDecl = Data.define(:name, :linkage_name, :forward_declarable, :source_module) do
       def initialize(name:, linkage_name:, forward_declarable:, source_module: nil) = super