mt-lang 0.3.42 → 0.4.0

data/lib/milk_tea/core/compile_time.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "types/layout"
+require_relative "compile_time/method_folding"
 
 module MilkTea
   module CompileTime
@@ -9,6 +10,10 @@ module MilkTea
     # Carries the value of a `return` statement out of the block evaluator as
     # an ordinary value instead of an exception; callers unwrap it when present.
     ReturnOutcome = Data.define(:value)
+    # Signals that a `break` was executed inside a compile-time loop body.
+    BreakOutcome = Data.define(:value)
+    # Signals that a `continue` was executed inside a compile-time loop body.
+    ContinueOutcome = Data.define(:value)
 
     class Error < StandardError
       def code
@@ -93,7 +98,7 @@ module MilkTea
           start_val = evaluate(expression.start_expr)
           end_val = evaluate(expression.end_expr)
           start_val.is_a?(Integer) && end_val.is_a?(Integer) ? (start_val...end_val).to_a : nil
-        when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
+        when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral, AST::CharLiteral
           expression.value
         when AST::StringLiteral
           expression.value
@@ -133,11 +138,98 @@ module MilkTea
           return unless CompileTime.boolean_value?(condition)
 
           evaluate(condition ? expression.then_expression : expression.else_expression)
+        when AST::MatchExpr
+          evaluate_match_expression(expression)
+        when AST::IndexAccess
+          evaluate_index_access(expression)
+        when AST::PrefixCast
+          evaluate_prefix_cast(expression)
         else
           nil
         end
       end
 
+      def evaluate_prefix_cast(expression)
+        operand = evaluate(expression.expression)
+        operand = 1 if operand == true
+        operand = 0 if operand == false
+        return nil unless operand.is_a?(Numeric)
+
+        target_type = begin
+          @resolve_type_ref&.call(expression.target_type)
+        rescue SemanticError
+          nil
+        end
+        return nil unless target_type.is_a?(Types::Primitive)
+
+        if target_type.boolean?
+          return operand != 0
+        end
+
+        if target_type.integer?
+          return nil unless target_type.integer_width
+
+          value = operand.is_a?(Float) ? operand.truncate : operand
+          return nil unless value.is_a?(Integer)
+
+          return wrap_integer(value, target_type.integer_width, target_type.signed_integer?)
+        end
+
+        return nil unless target_type.float?
+
+        value = operand.to_f
+        target_type.name == "float" ? float32_round(value) : value
+      end
+
+      def wrap_integer(value, width, signed)
+        mask = (1 << width) - 1
+        wrapped = value & mask
+        return wrapped unless signed
+
+        half = 1 << (width - 1)
+        wrapped >= half ? wrapped - (1 << width) : wrapped
+      end
+
+      def float32_round(value)
+        [value].pack("f").unpack1("f")
+      end
+
+      def evaluate_index_access(expression)
+        receiver = evaluate(expression.receiver)
+        return nil if receiver.nil?
+
+        if expression.index.is_a?(AST::RangeExpr)
+          start_val = evaluate(expression.index.start_expr)
+          end_val = evaluate(expression.index.end_expr)
+          return nil unless start_val.is_a?(Integer) && end_val.is_a?(Integer)
+
+          return receiver[start_val...end_val] if receiver.is_a?(Array) || receiver.is_a?(String)
+
+          return nil
+        end
+
+        index = evaluate(expression.index)
+        return nil unless index.is_a?(Integer)
+        return receiver[index] if receiver.is_a?(Array)
+        return receiver.getbyte(index) if receiver.is_a?(String)
+
+        nil
+      end
+
+      def evaluate_match_expression(expression)
+        scrutinee = evaluate(expression.expression)
+        return nil unless scrutinee
+
+        expression.arms.each do |arm|
+          wildcard = arm.pattern.is_a?(AST::Identifier) && arm.pattern.name == "_"
+          if wildcard || CompileTime.equality_result(scrutinee, evaluate(arm.pattern)) == true
+            return evaluate(arm.value)
+          end
+        end
+
+        nil
+      end
+
       def resolve_layout_type(type_ref)
         result = begin
           @resolve_type_ref&.call(type_ref)
@@ -207,7 +299,13 @@ module MilkTea
           result = CompileTime.equality_result(left, right)
           result.nil? ? nil : !result
         when "+"
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
+          if left.is_a?(String) && right.is_a?(String)
+            left + right
+          elsif left.is_a?(Numeric) && right.is_a?(Numeric)
+            left + right
+          else
+            nil
+          end
         when "-"
           left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
         when "*"
@@ -251,9 +349,10 @@ module MilkTea
     class BlockContext
       attr_reader :checker
 
-      def initialize(checker, initial_variables: nil)
+      def initialize(checker, initial_variables: nil, variable_types: nil)
         @checker = checker
         @variables = initial_variables || {}
+        @variable_types = variable_types || {}
       end
 
       def evaluate_block(statements, scopes: nil)
@@ -261,7 +360,7 @@ module MilkTea
 
         statements.each do |statement|
           outcome = evaluate_statement(statement, scopes:)
-          return outcome if outcome.is_a?(ReturnOutcome)
+          return outcome if control_outcome?(outcome)
 
           result = outcome
         end
@@ -269,6 +368,10 @@ module MilkTea
         result
       end
 
+      def control_outcome?(outcome)
+        outcome.is_a?(ReturnOutcome) || outcome.is_a?(BreakOutcome) || outcome.is_a?(ContinueOutcome)
+      end
+
       def evaluate_statement(statement, scopes:)
         case statement
         when AST::LocalDecl
@@ -288,9 +391,13 @@ module MilkTea
           evaluate_if(statement, scopes:)
         when AST::ExpressionStmt
           evaluate_expression(statement.expression, scopes:)
-        when AST::PassStmt, AST::BreakStmt, AST::ContinueStmt
+        when AST::PassStmt
           # no-op at compile time
           nil
+        when AST::BreakStmt
+          BreakOutcome.new(nil)
+        when AST::ContinueStmt
+          ContinueOutcome.new(nil)
         when AST::EmitStmt
           # emitted declarations are collected during lowering
           nil
@@ -312,9 +419,25 @@ module MilkTea
               @checker.evaluate_compile_time_const_value(id_expr, scopes:)
             },
             resolve_member_access: ->(ma_expr) {
+              if ma_expr.receiver.is_a?(AST::Identifier) && @variables.key?(ma_expr.receiver.name)
+                value = @variables[ma_expr.receiver.name]
+                case value
+                when Hash
+                  return value[ma_expr.member] if value.key?(ma_expr.member)
+                when Array
+                  if ma_expr.member =~ /\A_(\d+)\z/
+                    return value[Regexp.last_match(1).to_i]
+                  end
+                  return value.length if ma_expr.member == "len"
+                when String
+                  return value.length if ma_expr.member == "len"
+                end
+              end
+
               @checker.evaluate_compile_time_const_value(ma_expr, scopes:)
             },
             resolve_call: ->(call_expr) { resolve_compile_time_call(call_expr, scopes:) },
+            resolve_type_ref: ->(type_ref) { @checker.resolve_type_ref(type_ref) },
           )
         end
       end
@@ -323,26 +446,153 @@ module MilkTea
         return nil unless decl.value
 
         value = evaluate_expression(decl.value, scopes:)
+        return value unless value
+
+        if decl.else_body
+          return evaluate_guard_local_decl(decl, value, scopes:)
+        end
+
+        if decl.destructure_bindings&.any?
+          return evaluate_destructure_local_decl(decl, value)
+        end
+
+        @variables[decl.name] = value
+        @variable_types[decl.name] = compile_time_decl_type(decl.value, scopes:) unless @variable_types.key?(decl.name)
+        value
+      end
+
+      def evaluate_guard_local_decl(decl, value, scopes:)
+        if value.is_a?(CompileTime::VariantValue)
+          case value.arm
+          when "some", "success"
+            @variables[decl.name] = value.fields["value"]
+            @variable_types[decl.name] = compile_time_decl_type(decl.value, scopes:) unless @variable_types.key?(decl.name)
+            return value
+          when "none", "failure"
+            @variables[decl.else_binding.name] = value.fields["error"] if decl.else_binding
+            return evaluate_block(decl.else_body, scopes:)
+          end
+          return nil
+        end
+
         @variables[decl.name] = value
+        @variable_types[decl.name] = compile_time_decl_type(decl.value, scopes:) unless @variable_types.key?(decl.name)
         value
       end
 
+      def evaluate_destructure_local_decl(decl, value)
+        if value.is_a?(Array)
+          decl.destructure_bindings.each_with_index do |name, idx|
+            next if name == "_"
+
+            @variables[name] = value[idx]
+          end
+          return value
+        end
+
+        if value.is_a?(Hash)
+          field_names = destructure_field_names(decl.destructure_type_name)
+          decl.destructure_bindings.each_with_index do |name, idx|
+            next if name == "_"
+
+            field_name = field_names&.[](idx) || name
+            @variables[name] = value[field_name]
+          end
+          return value
+        end
+
+        nil
+      end
+
+      def destructure_field_names(type_name)
+        return nil unless type_name
+        return nil unless @checker.respond_to?(:comptime_struct_field_names)
+
+        @checker.comptime_struct_field_names(type_name)
+      rescue StandardError
+        nil
+      end
+
+      def compile_time_decl_type(expression, scopes:)
+        return nil unless @checker.respond_to?(:comptime_expression_type)
+
+        @checker.comptime_expression_type(expression, scopes:)
+      rescue StandardError
+        nil
+      end
+
       def evaluate_assignment(assignment, scopes:)
         value = evaluate_expression(assignment.value, scopes:)
+        return nil unless value
+
         case assignment.target
         when AST::Identifier
+          return nil unless @variables.key?(assignment.target.name)
+
           if assignment.operator != "="
             current = @variables[assignment.target.name]
             value = apply_compile_time_binary(assignment.operator.chomp("="), current, value)
           end
           @variables[assignment.target.name] = value
+        when AST::MemberAccess
+          return nil unless evaluate_member_assignment(assignment, value, scopes:)
+        when AST::IndexAccess
+          return nil unless evaluate_index_assignment(assignment, value, scopes:)
         end
         value
       end
 
+      def evaluate_member_assignment(assignment, value, scopes:)
+        target = assignment.target
+        return nil unless target.receiver.is_a?(AST::Identifier)
+        return nil unless @variables.key?(target.receiver.name)
+
+        receiver = @variables[target.receiver.name]
+        return nil unless receiver.is_a?(Hash)
+
+        if assignment.operator != "="
+          current = receiver[target.member]
+          value = apply_compile_time_binary(assignment.operator.chomp("="), current, value)
+          return nil unless value
+        end
+
+        updated = receiver.dup
+        updated[target.member] = value
+        @variables[target.receiver.name] = updated
+      end
+
+      def evaluate_index_assignment(assignment, value, scopes:)
+        target = assignment.target
+        return nil unless target.receiver.is_a?(AST::Identifier)
+        return nil unless @variables.key?(target.receiver.name)
+
+        receiver = @variables[target.receiver.name]
+        return nil unless receiver.is_a?(Array)
+
+        index = evaluate_expression(target.index, scopes:)
+        return nil unless index.is_a?(Integer)
+
+        if assignment.operator != "="
+          current = receiver[index]
+          value = apply_compile_time_binary(assignment.operator.chomp("="), current, value)
+          return nil unless value
+        end
+
+        updated = receiver.dup
+        updated[index] = value
+        @variables[target.receiver.name] = updated
+      end
+
       def apply_compile_time_binary(operator, left, right)
         case operator
-        when "+" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
+        when "+"
+          if left.is_a?(String) && right.is_a?(String)
+            left + right
+          elsif left.is_a?(Numeric) && right.is_a?(Numeric)
+            left + right
+          else
+            nil
+          end
         when "-" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
         when "*" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
         when "/" then left.is_a?(Numeric) && right.is_a?(Numeric) && !zero_numeric?(right) ? left / right : nil
@@ -371,7 +621,11 @@ module MilkTea
 
           statement.body.each do |body_stmt|
             outcome = evaluate_statement(body_stmt, scopes:)
-            return outcome if outcome.is_a?(ReturnOutcome)
+            case outcome
+            when ReturnOutcome then return outcome
+            when BreakOutcome then return result
+            when ContinueOutcome then break
+            end
           end
           iterations += 1
         end
@@ -392,32 +646,35 @@ module MilkTea
           @variables[loop_var_name] = element
           statement.body.each do |body_stmt|
             outcome = evaluate_statement(body_stmt, scopes:)
-            return outcome if outcome.is_a?(ReturnOutcome)
+            case outcome
+            when ReturnOutcome then return outcome
+            when BreakOutcome then return result
+            when ContinueOutcome then break
+            end
           end
         end
 
         result
       end
 
+      def run_body(body, scopes:, fallback: nil)
+        body.each do |body_stmt|
+          outcome = evaluate_statement(body_stmt, scopes:)
+          return outcome if control_outcome?(outcome)
+        end
+        fallback
+      end
+
       def evaluate_if(statement, scopes:)
         statement.branches.each do |branch|
           condition = evaluate_expression(branch.condition, scopes:)
-          if CompileTime.boolean_value?(condition) && condition
-            branch.body.each do |body_stmt|
-              outcome = evaluate_statement(body_stmt, scopes:)
-              return outcome if outcome.is_a?(ReturnOutcome)
-            end
-            return condition
-          end
-        end
+          next unless CompileTime.boolean_value?(condition) && condition
 
-        if statement.else_body
-          statement.else_body.each do |body_stmt|
-            outcome = evaluate_statement(body_stmt, scopes:)
-            return outcome if outcome.is_a?(ReturnOutcome)
-          end
+          return run_body(branch.body, scopes:, fallback: condition)
         end
 
+        return run_body(statement.else_body, scopes:) if statement.else_body
+
         nil
       end
 
@@ -428,11 +685,7 @@ module MilkTea
         statement.arms.each do |arm|
           wildcard = arm.pattern.is_a?(AST::Identifier) && arm.pattern.name == "_"
           if wildcard || CompileTime.equality_result(scrutinee, evaluate_expression(arm.pattern, scopes:)) == true
-            arm.body.each do |body_stmt|
-              outcome = evaluate_statement(body_stmt, scopes:)
-              return outcome if outcome.is_a?(ReturnOutcome)
-            end
-            return scrutinee
+            return run_body(arm.body, scopes:, fallback: scrutinee)
           end
         end
 
@@ -443,6 +696,9 @@ module MilkTea
         result = try_const_function_call(call_expr, scopes:)
         return result if result
 
+        result = try_const_method_call(call_expr, scopes:)
+        return result if result
+
         result = try_struct_constructor_call(call_expr, scopes:)
         return result if result
 
@@ -452,6 +708,27 @@ module MilkTea
         @checker.evaluate_compile_time_const_value(call_expr, scopes:)
       end
 
+      def try_const_method_call(call_expr, scopes:)
+        return unless call_expr.callee.is_a?(AST::MemberAccess)
+        return unless @checker.respond_to?(:comptime_method_binding_for_receiver)
+        return unless @checker.respond_to?(:comptime_const_method_body)
+
+        receiver = call_expr.callee.receiver
+        return unless receiver.is_a?(AST::Identifier)
+        return unless @variables.key?(receiver.name)
+
+        receiver_value = @variables[receiver.name]
+        return nil if receiver_value.nil? || receiver_value.is_a?(Types::Base)
+
+        receiver_type = @variable_types[receiver.name]
+        return nil unless receiver_type
+
+        binding = @checker.comptime_method_binding_for_receiver(receiver_type, call_expr.callee.member)
+        return nil unless binding
+
+        @checker.comptime_const_method_body(binding, call_expr.arguments, scopes:, receiver_value:)
+      end
+
       def try_const_function_call(call_expr, scopes:)
         return unless call_expr.callee.is_a?(AST::Identifier)
 

data/lib/milk_tea/core/lowering/async/normalization.rb

@@ -400,6 +400,8 @@ module MilkTea
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["span"]), arguments: [AST::TypeArgument.new(value: ast_type_ref_for(type.element_type))], nullable: false)
         when Types::Task
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["Task"]), arguments: [AST::TypeArgument.new(value: ast_type_ref_for(type.result_type))], nullable: false)
+        when Types::StringView
+          AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["str"]), arguments: [], nullable: false)
         when Types::TypeVar
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: [type.name]), arguments: [], nullable: false)
         when Types::StructInstance

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

@@ -1364,13 +1364,19 @@ module MilkTea
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
           receiver = lower_expression(expression.receiver, env:)
-          index = lower_expression(expression.index, env:)
-          if array_type?(receiver_type) && addressable_storage_expression?(expression.receiver)
-            IR::CheckedIndex.new(receiver:, index:, receiver_type:, type:)
-          elsif receiver_type.is_a?(Types::Span)
-            IR::CheckedSpanIndex.new(receiver:, index:, receiver_type:, type:)
+          if expression.index.is_a?(AST::RangeExpr)
+            lower_range_index_access(receiver, receiver_type, expression.index, env:, type:)
           else
-            IR::Index.new(receiver:, index:, type:)
+            index = lower_expression(expression.index, env:)
+            if array_type?(receiver_type) && addressable_storage_expression?(expression.receiver)
+              IR::CheckedIndex.new(receiver:, index:, receiver_type:, type:)
+            elsif receiver_type.is_a?(Types::Span)
+              IR::CheckedSpanIndex.new(receiver:, index:, receiver_type:, type:)
+            elsif receiver_type.is_a?(Types::StringView)
+              IR::Call.new(callee: "mt_str_index", arguments: [receiver, index], type:)
+            else
+              IR::Index.new(receiver:, index:, type:)
+            end
           end
         when AST::UnaryOp
           raise LoweringError.new("propagation expressions must be prepared before direct lowering", line: 0, column: 0, path: @ctx.current_analysis_path) if expression.operator == "?"
@@ -1452,6 +1458,25 @@ module MilkTea
         end
       end
 
+      def lower_range_index_access(receiver, receiver_type, range, env:, type:)
+        start = lower_range_index_bound(range.start_expr, env:)
+        stop = lower_range_index_bound(range.end_expr, env:)
+
+        if receiver_type.is_a?(Types::StringView)
+          return IR::Call.new(callee: "mt_str_slice", arguments: [receiver, start, stop], type:)
+        end
+
+        span_type = range_index_result_type(receiver_type)
+        span_argument = receiver_type.is_a?(Types::Span) ? receiver : lower_array_to_span_expression(receiver, span_type)
+        IR::Call.new(callee: span_slice_callee(span_type), arguments: [span_argument, start, stop], type: span_type)
+      end
+
+      def lower_range_index_bound(bound, env:)
+        ptr_uint = @ctx.types.fetch("ptr_uint")
+        lowered = lower_expression(bound, env:, expected_type: ptr_uint)
+        lowered.type == ptr_uint ? lowered : IR::Cast.new(target_type: ptr_uint, expression: lowered, type: ptr_uint)
+      end
+
       def lower_member_access(expression, env:, type:)
         if (type_expr = resolve_type_expression(expression.receiver))
           if type_expr.is_a?(Types::Variant)

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

@@ -206,6 +206,9 @@ module MilkTea
         when AST::IndexAccess
           collect_proc_captures_from_expression(expression.receiver, env, local_scopes, captures)
           collect_proc_captures_from_expression(expression.index, env, local_scopes, captures)
+        when AST::RangeExpr
+          collect_proc_captures_from_expression(expression.start_expr, env, local_scopes, captures)
+          collect_proc_captures_from_expression(expression.end_expr, env, local_scopes, captures)
         when AST::Specialization
           collect_proc_captures_from_expression(expression.callee, env, local_scopes, captures)
           expression.arguments.each { |argument| collect_proc_captures_from_expression(argument.value, env, local_scopes, captures) }

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

@@ -3,6 +3,7 @@
 module MilkTea
   module Lowering
     module Resolve
+      include CompileTime::MethodFolding
       PASS_THROUGH_BUILTINS = {
         "fatal"         => :fatal,
         "ref_of"        => :ref_of,
@@ -786,6 +787,9 @@ module MilkTea
           raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
+          if expression.index.is_a?(AST::RangeExpr)
+            return range_index_result_type(receiver_type)
+          end
           index_type = infer_expression_type(expression.index, env:)
           infer_index_result_type(receiver_type, index_type)
         when AST::UnaryOp
@@ -1555,7 +1559,7 @@ module MilkTea
                     end
                     resolve_current_module_const_value(identifier_expression.name)
                   end,
-                  resolve_member_access: lambda { |ma| nil },
+                  resolve_member_access: lambda { |ma| compile_time_const_value(ma, env:) },
                   resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
                   resolve_call: lambda { |ce| evaluate_compile_time_call(ce, env:) },
                 ))
@@ -1570,6 +1574,15 @@ module MilkTea
                 when "name" then next receiver_value.member_name
                 when "value" then next receiver_value.member_value
                 end
+              when Hash
+                next receiver_value[member_access_expression.member] if receiver_value.key?(member_access_expression.member)
+              when Array
+                if member_access_expression.member =~ /\A_(\d+)\z/
+                  next receiver_value[Regexp.last_match(1).to_i]
+                end
+                next receiver_value.length if member_access_expression.member == "len"
+              when String
+                next receiver_value.length if member_access_expression.member == "len"
               end
             end
 
@@ -1591,6 +1604,11 @@ module MilkTea
 
       def evaluate_compile_time_call(expression, env:)
         case expression.callee
+        when AST::MemberAccess
+          if (method_binding = comptime_method_binding(expression.callee, env))
+            receiver_value = comptime_member_receiver_value(expression.callee.receiver, env)
+            return comptime_const_method_body(method_binding, expression.arguments, scopes: nil, receiver_value:)
+          end
         when AST::Identifier
           case expression.callee.name
           when "field_of"
@@ -1791,12 +1809,51 @@ module MilkTea
           initial_vars[param.name] = arg_value
         end
 
+        variable_types = func.body_params.each_with_object({}) do |param, acc|
+          acc[param.name] = param.type
+        end
         evaluator = ConstFnLowerEvaluator.new(self)
-        ctx = CompileTime::BlockContext.new(evaluator, initial_variables: initial_vars)
+        ctx = CompileTime::BlockContext.new(evaluator, initial_variables: initial_vars, variable_types: variable_types)
         result = ctx.evaluate_block(func.ast.body, scopes: nil)
         result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
       end
 
+      def comptime_methods_map
+        @ctx.methods
+      end
+
+      def comptime_methods_map_by_to_s(type)
+        entry = @ctx.methods.find { |k, _| k.to_s == type.to_s }
+        entry&.last
+      end
+
+      def comptime_scoped_value_type(name, ctx)
+        return nil unless ctx
+
+        binding = lookup_value(name, ctx)
+        binding[:type] if binding && binding[:type]
+      end
+
+      def comptime_value_type(name)
+        @ctx.values[name]&.type
+      end
+
+      def comptime_const_function(name)
+        @ctx.functions[name]
+      end
+
+      def comptime_eval(expression, _scopes)
+        compile_time_const_value(expression, env: empty_env)
+      end
+
+      def comptime_block_context(initial_vars, variable_types)
+        ::MilkTea::CompileTime::BlockContext.new(ConstFnLowerEvaluator.new(self), initial_variables: initial_vars, variable_types: variable_types)
+      end
+
+      def comptime_raise_error(error)
+        raise error
+      end
+
       class ConstFnLowerEvaluator
         def initialize(lowerer)
           @lowerer = lowerer
@@ -1813,6 +1870,26 @@ module MilkTea
         def top_level_function(name)
           @lowerer.instance_variable_get(:@ctx).functions&.[](name)
         end
+
+        def resolve_type_ref(type_ref)
+          @lowerer.resolve_type_ref(type_ref)
+        end
+
+        def comptime_struct_field_names(type_name)
+          @lowerer.comptime_struct_field_names(type_name)
+        end
+
+        def comptime_method_binding_for_receiver(receiver_type, member)
+          @lowerer.comptime_method_binding_for_receiver(receiver_type, member)
+        end
+
+        def comptime_const_method_body(binding, arguments, scopes: nil, receiver_value: nil)
+          @lowerer.comptime_const_method_body(binding, arguments, scopes:, receiver_value:)
+        end
+
+        def comptime_expression_type(expression, scopes: nil)
+          @lowerer.comptime_expression_type(expression, scopes:)
+        end
       end
 
       def evaluate_reflection_target_argument(expression, env:)