mt-lang 0.3.17 → 0.3.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2f84289b1bcb599ca81cbada0b1e1a925d9962ffe186471b84026f372fb358b
-  data.tar.gz: 566b98b015518f583e31fa2f0a75753c3b0abfd5a4047210945b3209c3caf1f3
+  metadata.gz: 6dc76fcf0acde63fa4060157d6c6864dedcc32b0f5c2cd60422e9948d9861dab
+  data.tar.gz: 0b1bf5aee4d6be4d0f1968a7dacaf35e37557336a5911834a17324d23bd60ba3
 SHA512:
-  metadata.gz: ee114072cb26ed2527e0b3703cb7f8a913e37234e6937b3a307ce72363e8a6e10a34e0a149d508a8c02e64c1a0a0f5e9b1ae482b76f068bfb6bf0b8784f34a44
-  data.tar.gz: 9b29c88530cf6110381123ef8135434caa47aa85abf955a8bd9f25d93fa1b8059691d52804c17e4080a2a3d0ad916aa689470ec8d7719a7186fa62eddb026525
+  metadata.gz: 1b34537660a1c2424b3f829ff6ef18d35de4366fe76d0a0938216261b1f9c7c56d8fce2c8a0ac1162f17ddc8c1a2c565f9e08f2f5f0056624f4959d35833cabf
+  data.tar.gz: 9b6b00b5b761ab3128c617acb8398c64b829df1e2d6984661bc6e8bfb2081b9fa408fd5e8774e1b540884a59caef4eef146c3a05f0d176cb62019471b4e28b88

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.17"
+  VERSION = "0.3.22"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

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

@@ -331,11 +331,10 @@ module MilkTea
       end
 
       def emit_cast_operand(expression)
-        case expression
-        when IR::Name, IR::IntegerLiteral, IR::FloatLiteral, IR::StringLiteral, IR::BooleanLiteral, IR::NullLiteral, IR::ZeroInit, IR::Member, IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex, IR::Call, IR::AggregateLiteral, IR::ArrayLiteral, IR::ReinterpretExpr, IR::SizeofExpr, IR::AlignofExpr, IR::OffsetofExpr, IR::AddressOf, IR::Cast, IR::Unary
-          emit_expression(expression)
-        else
+        if expression.is_a?(IR::Binary) || expression.is_a?(IR::Conditional)
           "(#{emit_expression(expression)})"
+        else
+          emit_expression(expression)
         end
       end
 
@@ -425,28 +424,16 @@ module MilkTea
 
       def emit_variant_field_initializer(type, arm_name, field)
         field_type = type.arm(arm_name).fetch(field.name)
+        outer_c = named_type_c_name(type)
+
         if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
           emit_nullable_some_initializer(field_type, field.value)
         elsif field.value.is_a?(IR::AddressOf) && !field_type.is_a?(Types::Nullable)
-          c_type_name = named_type_c_name(field_type)
-          inner = field.value.expression
-          "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
-        elsif aggregate_field_creates_cycle?(field_type, named_type_c_name(type)) &&
-              array_type?(field_type)
-          elem_c_name = c_type(array_element_type(field_type))
-          elem_count = array_length(field_type)
-          elements = field.value.is_a?(IR::ArrayLiteral) ? field.value.elements.map { |e| emit_initializer(e) }.join(", ") : ""
-          "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), &(#{elem_c_name}[#{elem_count}]){ #{elements} }, #{elem_count} * sizeof(#{elem_c_name})))"
-        elsif aggregate_field_creates_cycle?(field_type, named_type_c_name(type)) &&
-              !field_type.is_a?(Types::GenericInstance)
-          field_c_name = named_type_c_name(field_type)
-          init = emit_initializer(field.value)
-          source_expr = if init.start_with?("{")
-            "&(#{c_type(field_type)})#{init}"
-          else
-            "&(#{init})"
-          end
-          "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
+          emit_addressof_field_initializer(field_type, field.value)
+        elsif aggregate_field_creates_cycle?(field_type, outer_c) && array_type?(field_type)
+          emit_cyclic_array_initializer(field_type, field.value)
+        elsif aggregate_field_creates_cycle?(field_type, outer_c) && !field_type.is_a?(Types::GenericInstance)
+          emit_cyclic_struct_initializer(field_type, field.value)
         elsif void_storage_field?(field_type)
           emit_void_field_initializer(field.value)
         else
@@ -454,6 +441,30 @@ module MilkTea
         end
       end
 
+      def emit_addressof_field_initializer(field_type, value)
+        c_type_name = named_type_c_name(field_type)
+        inner = value.expression
+        "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
+      end
+
+      def emit_cyclic_array_initializer(field_type, value)
+        elem_c_name = c_type(array_element_type(field_type))
+        elem_count = array_length(field_type)
+        elements = value.is_a?(IR::ArrayLiteral) ? value.elements.map { |e| emit_initializer(e) }.join(", ") : ""
+        "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), &(#{elem_c_name}[#{elem_count}]){ #{elements} }, #{elem_count} * sizeof(#{elem_c_name})))"
+      end
+
+      def emit_cyclic_struct_initializer(field_type, value)
+        field_c_name = named_type_c_name(field_type)
+        init = emit_initializer(value)
+        source_expr = if init.start_with?("{")
+          "&(#{c_type(field_type)})#{init}"
+        else
+          "&(#{init})"
+        end
+        "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
+      end
+
       def emit_void_field_initializer(expression)
         "(#{emit_expression(expression)}, 0)"
       end

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

@@ -342,66 +342,46 @@ module MilkTea
         function.body.any? { |statement| statement_uses_str_equality?(statement) }
       end
 
-      def statement_uses_named_call?(statement, callees)
+      def any_ir_statement?(statement, expression_pred:, **kwargs)
         case statement
         when IR::LocalDecl
-          expression_uses_named_call?(statement.value, callees)
+          statement.value && expression_pred.call(statement.value, **kwargs)
         when IR::Assignment
-          expression_uses_named_call?(statement.target, callees) || expression_uses_named_call?(statement.value, callees)
+          expression_pred.call(statement.target, **kwargs) || expression_pred.call(statement.value, **kwargs)
         when IR::BlockStmt
-          statement.body.any? { |inner| statement_uses_named_call?(inner, callees) }
+          statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) }
         when IR::WhileStmt
-          expression_uses_named_call?(statement.condition, callees) || statement.body.any? { |inner| statement_uses_named_call?(inner, callees) }
+          expression_pred.call(statement.condition, **kwargs) ||
+            statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) }
         when IR::ForStmt
-          statement_uses_named_call?(statement.init, callees) ||
-            expression_uses_named_call?(statement.condition, callees) ||
-            statement.body.any? { |inner| statement_uses_named_call?(inner, callees) } ||
-            statement_uses_named_call?(statement.post, callees)
+          any_ir_statement?(statement.init, expression_pred:, **kwargs) ||
+            expression_pred.call(statement.condition, **kwargs) ||
+            statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } ||
+            any_ir_statement?(statement.post, expression_pred:, **kwargs)
         when IR::IfStmt
-          expression_uses_named_call?(statement.condition, callees) ||
-            statement.then_body.any? { |inner| statement_uses_named_call?(inner, callees) } ||
-            (statement.else_body && statement.else_body.any? { |inner| statement_uses_named_call?(inner, callees) })
+          expression_pred.call(statement.condition, **kwargs) ||
+            statement.then_body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } ||
+            (statement.else_body && statement.else_body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) })
         when IR::SwitchStmt
-          expression_uses_named_call?(statement.expression, callees) || statement.cases.any? { |switch_case| switch_case.body.any? { |inner| statement_uses_named_call?(inner, callees) } }
+          expression_pred.call(statement.expression, **kwargs) ||
+            statement.cases.any? { |switch_case| switch_case.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } }
         when IR::StaticAssert
-          expression_uses_named_call?(statement.condition, callees) || expression_uses_named_call?(statement.message, callees)
+          expression_pred.call(statement.condition, **kwargs) || expression_pred.call(statement.message, **kwargs)
         when IR::ReturnStmt
-          statement.value && expression_uses_named_call?(statement.value, callees)
+          statement.value && expression_pred.call(statement.value, **kwargs)
         when IR::ExpressionStmt
-          expression_uses_named_call?(statement.expression, callees)
+          expression_pred.call(statement.expression, **kwargs)
+        else
+          false
         end
       end
 
+      def statement_uses_named_call?(statement, callees)
+        any_ir_statement?(statement, expression_pred: ->(e) { expression_uses_named_call?(e, callees) })
+      end
+
       def statement_uses_str_equality?(statement)
-        case statement
-        when IR::LocalDecl
-          expression_uses_str_equality?(statement.value)
-        when IR::Assignment
-          expression_uses_str_equality?(statement.target) || expression_uses_str_equality?(statement.value)
-        when IR::BlockStmt
-          statement.body.any? { |inner| statement_uses_str_equality?(inner) }
-        when IR::WhileStmt
-          expression_uses_str_equality?(statement.condition) || statement.body.any? { |inner| statement_uses_str_equality?(inner) }
-        when IR::ForStmt
-          statement_uses_str_equality?(statement.init) ||
-            expression_uses_str_equality?(statement.condition) ||
-            statement.body.any? { |inner| statement_uses_str_equality?(inner) } ||
-            statement_uses_str_equality?(statement.post)
-        when IR::IfStmt
-          expression_uses_str_equality?(statement.condition) ||
-            statement.then_body.any? { |inner| statement_uses_str_equality?(inner) } ||
-            (statement.else_body && statement.else_body.any? { |inner| statement_uses_str_equality?(inner) })
-        when IR::SwitchStmt
-          expression_uses_str_equality?(statement.expression) || statement.cases.any? { |switch_case| switch_case.body.any? { |inner| statement_uses_str_equality?(inner) } }
-        when IR::StaticAssert
-          expression_uses_str_equality?(statement.condition) || expression_uses_str_equality?(statement.message)
-        when IR::ReturnStmt
-          statement.value && expression_uses_str_equality?(statement.value)
-        when IR::ExpressionStmt
-          expression_uses_str_equality?(statement.expression)
-        else
-          false
-        end
+        any_ir_statement?(statement, expression_pred: ->(e) { expression_uses_str_equality?(e) })
       end
 
       def expression_uses_named_call?(expression, callees)

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

@@ -241,21 +241,15 @@ module MilkTea
       end
 
       def collect_soa_from_statements(statements, soa_types, visited)
-        statements.each do |stmt|
-          case stmt
-          when IR::LocalDecl
-            collect_soa_type(stmt.type, soa_types, visited)
-          when IR::BlockStmt
-            collect_soa_from_statements(stmt.body, soa_types, visited)
-          when IR::IfStmt
-            collect_soa_from_statements(stmt.then_body || [], soa_types, visited)
-            collect_soa_from_statements(stmt.else_body || [], soa_types, visited)
-          when IR::WhileStmt
-            collect_soa_from_statements(stmt.body || [], soa_types, visited)
-          when IR::ForStmt
-            collect_soa_from_statements(stmt.body || [], soa_types, visited)
-          end
-        end
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_soa_type,
+          expression_walker_method: :collect_soa_type_in_expression,
+          accumulator: soa_types, visited:)
+      end
+
+      def collect_soa_type_in_expression(expression, soa_types, visited)
+        return unless expression.respond_to?(:type)
+        collect_soa_type(expression.type, soa_types, visited)
       end
 
       def collect_soa_type(type, soa_types, visited)
@@ -290,21 +284,15 @@ module MilkTea
       end
 
       def collect_simd_from_statements(statements, simd_types, visited)
-        statements.each do |stmt|
-          case stmt
-          when IR::LocalDecl
-            collect_simd_type(stmt.type, simd_types, visited)
-          when IR::BlockStmt
-            collect_simd_from_statements(stmt.body, simd_types, visited)
-          when IR::IfStmt
-            collect_simd_from_statements(stmt.then_body || [], simd_types, visited)
-            collect_simd_from_statements(stmt.else_body || [], simd_types, visited)
-          when IR::WhileStmt
-            collect_simd_from_statements(stmt.body || [], simd_types, visited)
-          when IR::ForStmt
-            collect_simd_from_statements(stmt.body || [], simd_types, visited)
-          end
-        end
+        each_ir_statement_for_type_collection(statements,
+          type_collector_method: :collect_simd_type,
+          expression_walker_method: :collect_simd_type_in_expression,
+          accumulator: simd_types, visited:)
+      end
+
+      def collect_simd_type_in_expression(expression, simd_types, visited)
+        return unless expression.respond_to?(:type)
+        collect_simd_type(expression.type, simd_types, visited)
       end
 
       def collect_simd_type(type, simd_types, visited)

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

@@ -61,12 +61,6 @@ module MilkTea
         lines
       end
 
-      def variant_self_reference?(type, outer_c)
-        return false unless type.is_a?(Types::Variant) || type.is_a?(Types::VariantInstance)
-
-        named_type_c_name(type) == outer_c
-      end
-
       def emit_variant(variant_decl)
         lines = []
         outer_c = variant_decl.linkage_name

data/lib/milk_tea/core/c_backend.rb

@@ -75,11 +75,27 @@ module MilkTea
 
     def emit
       lines = []
+      @cyclic_aggregate_pairs = build_cyclic_aggregate_pairs(
+        emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls +
+        emitted_aggregate_unions +
+        emitted_aggregate_variants + collect_generic_variant_decls
+      )
+
       constants = emitted_constants
-      all_struct_decls = emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls
-      all_variant_decls = emitted_aggregate_variants + collect_generic_variant_decls
-      all_decls_for_cycle = all_struct_decls + emitted_aggregate_unions + all_variant_decls
-      @cyclic_aggregate_pairs = build_cyclic_aggregate_pairs(all_decls_for_cycle)
+
+      emit_preamble(lines)
+      emit_conditional_helpers(lines)
+      emit_type_declarations(lines)
+      emit_function_forward_declarations(lines)
+      emit_globals_and_constants(lines, constants)
+      emit_per_type_helpers(lines)
+      emit_string_literal_constants_section(lines)
+      emit_function_definitions(lines)
+
+      lines.join("\n").rstrip + "\n"
+    end
+
+    def emit_preamble(lines)
       headers = @program.includes.map(&:header)
       if headers.include?("\"fs_support.h\"") || headers.include?("\"tls_support.h\"") || uses_parallel_for_helper? || uses_spawn_all_helper? || uses_detach_helper?
         lines << "#ifndef _GNU_SOURCE"
@@ -103,70 +119,61 @@ module MilkTea
         lines << "#include #{header}"
       end
       lines << ""
+    end
 
+    def emit_conditional_helpers(lines)
       if uses_string_view?
         lines.concat(emit_string_type)
         lines << ""
       end
-
       if uses_vector_math_types?
         lines.concat(emit_vector_math_types)
         lines << ""
       end
-
       if uses_fatal_helper?
         lines.concat(emit_fatal_helper)
         lines << ""
       end
-
       if uses_format_helpers?
         lines.concat(emit_format_helpers)
         lines << ""
       end
-
       if uses_fmt_builder?
         lines.concat(emit_fmt_builder_helpers)
         lines << ""
       end
-
       if uses_str_equality_helper?
         lines.concat(emit_str_equality_helper)
         lines << ""
       end
-
       if uses_text_buffer_helpers?
         lines.concat(emit_text_buffer_helpers)
         lines << ""
       end
-
       if uses_async_memory_helpers?
         lines.concat(emit_async_memory_helpers)
         lines << ""
       end
-
       if uses_parallel_for_helper?
         lines.concat(emit_parallel_for_helper)
         lines << ""
       end
-
       if uses_spawn_all_helper?
         lines.concat(emit_spawn_all_helper)
         lines << ""
       end
-
       if uses_detach_helper?
         lines.concat(emit_detach_helpers)
         lines << ""
       end
+    end
 
-      opaque_decls = @program.opaques
-      aggregate_decls = sort_aggregate_decls(
-        all_struct_decls,
-        emitted_aggregate_unions,
-        all_variant_decls,
-      )
+    def emit_type_declarations(lines)
+      all_struct_decls = emitted_aggregate_structs + collect_generic_struct_decls + collect_task_decls + collect_proc_decls + collect_dyn_decls + collect_str_buffer_decls + collect_nullable_opt_decls
+      all_variant_decls = emitted_aggregate_variants + collect_generic_variant_decls
+      aggregate_decls = sort_aggregate_decls(all_struct_decls, emitted_aggregate_unions, all_variant_decls)
 
-      forward_declarations = emit_forward_declarations(opaque_decls, aggregate_decls)
+      forward_declarations = emit_forward_declarations(@program.opaques, aggregate_decls)
       unless forward_declarations.empty?
         lines.concat(forward_declarations)
         lines << ""
@@ -236,13 +243,17 @@ module MilkTea
         lines.concat(emit_variant_equality_helpers)
         lines << ""
       end
+    end
 
+    def emit_function_forward_declarations(lines)
       function_declarations = emit_function_declarations(emitted_functions)
       unless function_declarations.empty?
         lines.concat(function_declarations)
         lines << ""
       end
+    end
 
+    def emit_globals_and_constants(lines, constants)
       constants.each do |constant|
         @current_line = constant.line if constant.line
         @source_path ||= constant.path if constant.path
@@ -262,51 +273,50 @@ module MilkTea
         lines << emit_static_assert(statement)
       end
       lines << "" unless @program.static_asserts.empty?
+    end
 
-      reinterpret_helpers = collect_reinterpret_helpers
-      reinterpret_helpers.each do |helper|
+    def emit_per_type_helpers(lines)
+      collect_reinterpret_helpers.each do |helper|
         lines.concat(emit_reinterpret_helper(helper))
         lines << ""
       end
 
-      checked_array_index_types = collect_checked_array_index_types
-      checked_array_index_types.each do |type|
+      collect_checked_array_index_types.each do |type|
         lines.concat(emit_checked_array_index_helper(type))
         lines << ""
       end
 
-      checked_span_index_types = collect_checked_span_index_types
-      checked_span_index_types.each do |type|
+      collect_checked_span_index_types.each do |type|
         lines.concat(emit_checked_span_index_helper(type))
         lines << ""
       end
 
-      nullable_array_index_types = collect_checked_array_index_types(nullable_only: true)
-      nullable_array_index_types.each do |type|
+      collect_checked_array_index_types(nullable_only: true).each do |type|
         lines.concat(emit_nullable_array_index_helper(type))
         lines << ""
       end
 
-      nullable_span_index_types = collect_checked_span_index_types(nullable_only: true)
-      nullable_span_index_types.each do |type|
+      collect_checked_span_index_types(nullable_only: true).each do |type|
         lines.concat(emit_nullable_span_index_helper(type))
         lines << ""
       end
+    end
 
+    def emit_string_literal_constants_section(lines)
       str_literals = collect_str_literals
-      unless str_literals.empty?
-        @str_literal_map = {}
-        str_literals.each_with_index { |value, i| @str_literal_map[value] = str_literal_name(i) }
-        lines.concat(emit_str_literal_constants(str_literals))
-        lines << ""
-      end
+      return if str_literals.empty?
+
+      @str_literal_map = {}
+      str_literals.each_with_index { |value, i| @str_literal_map[value] = str_literal_name(i) }
+      lines.concat(emit_str_literal_constants(str_literals))
+      lines << ""
+    end
 
+    def emit_function_definitions(lines)
       emitted_functions.each do |function|
         lines.concat(emit_function(function))
         lines << ""
       end
-
-      lines.join("\n").rstrip + "\n"
     end
   end
 end

data/lib/milk_tea/core/compile_time.rb

@@ -252,75 +252,7 @@ module MilkTea
             resolve_member_access: ->(ma_expr) {
               @checker.evaluate_compile_time_const_value(ma_expr, scopes:)
             },
-            resolve_call: ->(call_expr) {
-              if call_expr.callee.is_a?(AST::Identifier)
-                func = @checker.top_level_function(call_expr.callee.name)
-                if func&.ast&.respond_to?(:const) && func.ast.const
-                  begin
-                    initial_vars = {}
-                    func.ast.params.each_with_index do |param, idx|
-                      return nil if idx >= call_expr.arguments.length
-
-                      arg_expr = call_expr.arguments[idx].value
-                      arg_value = case arg_expr
-                      when AST::Identifier
-                        @variables[arg_expr.name] || @checker.evaluate_compile_time_const_value(arg_expr, scopes:)
-                      else
-                        CompileTime.evaluate(
-                          arg_expr,
-                          resolve_identifier: ->(id) { @variables[id.name] || @checker.evaluate_compile_time_const_value(id, scopes:) },
-                          resolve_member_access: ->(ma) { @checker.evaluate_compile_time_const_value(ma, scopes:) },
-                          resolve_type_ref: nil,
-                          resolve_call: nil,
-                        )
-                      end
-                      return nil unless arg_value
-
-                      initial_vars[param.name] = arg_value
-                    end
-                    ctx = CompileTime::BlockContext.new(@checker, initial_variables: initial_vars)
-                    next ctx.evaluate_block(func.ast.body, scopes:)
-                  rescue CompileTime::ReturnValue => e
-                    next e.value
-                  end
-                end
-              end
-
-              types = if @checker.respond_to?(:types)
-                @checker.types
-              else
-                @checker.instance_variable_get(:@ctx).types
-              end
-              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:)
-                  return nil unless val
-                  fields[argument.name] = val
-                end
-                next fields
-              end
-
-              if call_expr.callee.is_a?(AST::Specialization) && @checker.respond_to?(:resolve_type_expression)
-                resolved = @checker.resolve_type_expression(call_expr.callee)
-                if resolved && @checker.respond_to?(:array_type?) && @checker.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.evaluate_compile_time_const_value(call_expr, scopes:)
-            },
+            resolve_call: ->(call_expr) { resolve_compile_time_call(call_expr, scopes:) },
           )
         end
       end
@@ -435,13 +367,108 @@ module MilkTea
 
         nil
       end
+
+      def resolve_compile_time_call(call_expr, scopes:)
+        result = try_const_function_call(call_expr, scopes:)
+        return result if result
+
+        result = try_struct_constructor_call(call_expr, scopes:)
+        return result if result
+
+        result = try_array_constructor_call(call_expr, scopes:)
+        return result if result
+
+        @checker.evaluate_compile_time_const_value(call_expr, scopes:)
+      end
+
+      def try_const_function_call(call_expr, scopes:)
+        return unless call_expr.callee.is_a?(AST::Identifier)
+
+        func = @checker.top_level_function(call_expr.callee.name)
+        return unless func&.ast&.respond_to?(:const) && func.ast.const
+
+        begin
+          initial_vars = {}
+          func.ast.params.each_with_index do |param, idx|
+            return nil if idx >= call_expr.arguments.length
+
+            arg_expr = call_expr.arguments[idx].value
+            arg_value = case arg_expr
+            when AST::Identifier
+              @variables[arg_expr.name] || @checker.evaluate_compile_time_const_value(arg_expr, scopes:)
+            else
+              CompileTime.evaluate(
+                arg_expr,
+                resolve_identifier: ->(id) { @variables[id.name] || @checker.evaluate_compile_time_const_value(id, scopes:) },
+                resolve_member_access: ->(ma) { @checker.evaluate_compile_time_const_value(ma, scopes:) },
+                resolve_type_ref: nil,
+                resolve_call: nil,
+              )
+            end
+            return nil unless arg_value
+
+            initial_vars[param.name] = arg_value
+          end
+          ctx = BlockContext.new(@checker, initial_variables: initial_vars)
+          ctx.evaluate_block(func.ast.body, scopes:)
+        rescue ReturnValue => e
+          e.value
+        end
+      end
+
+      def try_struct_constructor_call(call_expr, scopes:)
+        types = if @checker.respond_to?(:types)
+          @checker.types
+        else
+          @checker.instance_variable_get(:@ctx).types
+        end
+        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
+        return unless callee_name
+
+        type = types[callee_name]
+        return unless type.is_a?(Types::Struct)
+
+        fields = {}
+        call_expr.arguments.each do |argument|
+          val = evaluate_expression(argument.value, scopes:)
+          return nil unless val
+          fields[argument.name] = val
+        end
+        fields
+      end
+
+      def try_array_constructor_call(call_expr, scopes:)
+        return unless call_expr.callee.is_a?(AST::Specialization)
+        return unless @checker.respond_to?(:resolve_type_expression)
+
+        resolved = @checker.resolve_type_expression(call_expr.callee)
+        return unless resolved && @checker.respond_to?(:array_type?) && @checker.array_type?(resolved)
+
+        values = []
+        call_expr.arguments.each do |argument|
+          val = evaluate_expression(argument.value, scopes:)
+          return nil unless val
+          values << val
+        end
+        values
+      end
     end
 
     class Evaluator < ConstEval::Evaluator
 
       def resolve_layout_type(type_ref)
-        super
-      rescue SemanticError
+        result = begin
+          super
+        rescue SemanticError
+          nil
+        end
+        return result if result
+        return result if result
+
         return unless type_ref.respond_to?(:name) && type_ref.name.parts.length >= 1
 
         expression = ::MilkTea::AST.build_chain_from_parts(type_ref.name.parts)
@@ -455,7 +482,6 @@ module MilkTea
         nil
       end
 
-
     end
 
     def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)