mt-lang 0.3.43 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6842b1cfb6eac5181fdbcd31cd90dbb9f436bb0f3c7b0cc25d49a8c1f8e13a8b
-  data.tar.gz: 4e97091f3da86a115656c6ec7d9bb10fe5cd65360bd59a203fc6595111285aff
+  metadata.gz: 990a1e0ede945713a31152caccc4a7de798dc6ead6078d46d5a376f19054a52a
+  data.tar.gz: 97d7877587ca50ab673212d1d0d80d6d60ad8f97a74c439965feb32c2f5a4e37
 SHA512:
-  metadata.gz: 71630831d0eceda79fefdd93b07a9f83b48c3ef3b0cd879c5c7db8b064e459ef321d36b49a2e0d46e8ba20f134fffc65039cdf455d3cc47638ea031c3edddd83
-  data.tar.gz: b7fccbe3f6547fcb7e17c07b9002d278965934a0f0ec68d1b6c79a1ce5b48d807186633a9e57b75e34c8671413ed984a18823a575719ba1f8af4e3777c3309f3
+  metadata.gz: c04b4d611724c8b4f42ae14929b3d8d98b4aa4da5157f7c3ee765afb6356be643b6ada8c96ed45a8e61103e71792c7855c25d87f65865b9609cdb0cc85544507
+  data.tar.gz: 82416c2665d49928f0d6dd5e9b8f225177f9df0f782e973339545a6375cc673e082bccc3bbb6126cbdc50875dc6fa29880b5e23b8e3ccd458934b32f5d2f6718

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -120,8 +120,8 @@ module MilkTea
     FunctionDef = Data.define(:name, :type_params, :params, :return_type, :body, :visibility, :async, :const, :attributes, :line, :column) do
       def initialize(name:, type_params:, params:, return_type:, body:, visibility:, async:, const: false, attributes: [], line: nil, column: nil) = super
     end
-    MethodDef = Data.define(:name, :type_params, :params, :return_type, :body, :kind, :visibility, :async, :attributes, :line, :column) do
-      def initialize(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes: [], line: nil, column: nil) = super
+    MethodDef = Data.define(:name, :type_params, :params, :return_type, :body, :kind, :visibility, :async, :const, :attributes, :line, :column) do
+      def initialize(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, const: false, attributes: [], line: nil, column: nil) = super
     end
     ExternFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :attributes, :line, :column, :mapping) do
       def initialize(name:, type_params:, params:, return_type:, variadic:, attributes: [], line: nil, column: nil, mapping: nil) = super

data/lib/milk_tea/core/compile_time/method_folding.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module CompileTime
+    # Compile-time folding for const-method calls and the resolution helpers
+    # behind them. Included by both the semantic checker and the lowering
+    # engine so the folding behavior lives in one place instead of two
+    # near-identical copies. Each includer supplies a small set of `comptime_*`
+    # adapters for the phase-specific lookups (ctx maps, scope/env evaluation,
+    # and the BlockContext factory).
+    module MethodFolding
+      def comptime_methods_map_for_binding(type, keys)
+        dispatch_type = type.respond_to?(:definition) ? type.definition : type
+        method_map = comptime_methods_map.fetch(dispatch_type, nil)
+        method_map ||= comptime_methods_map_by_to_s(dispatch_type)
+        return nil unless method_map
+
+        keys.each do |key|
+          binding = method_map[key]
+          next unless binding
+
+          ast = binding.ast
+          next unless ast.respond_to?(:const) && ast.const && ast.body
+          next unless binding.type_params.empty?
+
+          return binding
+        end
+        nil
+      end
+
+      def comptime_method_binding(member_access, ctx)
+        member = member_access.member
+        keys = ["static:#{member}", member]
+
+        if (type = resolve_type_expression(member_access.receiver)) &&
+           (binding = comptime_methods_map_for_binding(type, keys))
+          return binding
+        end
+
+        receiver_type = comptime_receiver_type(member_access.receiver, ctx)
+        return nil unless receiver_type
+
+        comptime_methods_map_for_binding(receiver_type, keys)
+      end
+
+      def comptime_method_binding_for_receiver(receiver_type, member)
+        comptime_methods_map_for_binding(receiver_type, ["static:#{member}", member])
+      end
+
+      def comptime_receiver_type(receiver, ctx)
+        case receiver
+        when AST::Identifier
+          type = comptime_scoped_value_type(receiver.name, ctx)
+          return type if type
+
+          comptime_value_type(receiver.name)
+        when AST::MemberAccess
+          return nil unless receiver.receiver.is_a?(AST::Identifier)
+
+          comptime_imported_value_type(receiver.receiver.name, receiver.member)
+        when AST::Call, AST::Specialization
+          comptime_call_return_type(receiver, ctx)
+        end
+      end
+
+      def comptime_member_receiver_value(receiver, ctx)
+        return nil if resolve_type_expression(receiver)
+
+        comptime_eval(receiver, ctx)
+      end
+
+      def comptime_call_return_type(call_expr, ctx)
+        case call_expr.callee
+        when AST::MemberAccess
+          binding = comptime_method_binding(call_expr.callee, ctx)
+          return binding.body_return_type if binding
+        when AST::Identifier
+          func = comptime_const_function(call_expr.callee.name)
+          return func.body_return_type if comptime_const_function_return?(func)
+        when AST::Specialization
+          callee_name = call_expr.callee.callee.is_a?(AST::Identifier) ? call_expr.callee.callee.name : nil
+          if callee_name
+            func = comptime_const_function(callee_name)
+            return func.body_return_type if comptime_const_function_return?(func)
+          end
+        end
+        nil
+      end
+
+      def comptime_expression_type(expression, scopes:)
+        case expression
+        when AST::Call, AST::Specialization
+          comptime_call_return_type(expression, scopes)
+        end
+      end
+
+      def comptime_struct_field_names(type_name)
+        parts = type_name.is_a?(Array) ? type_name.map(&:to_s) : [type_name.to_s]
+        return nil if parts.empty?
+
+        type = resolve_type_expression(::MilkTea::AST.build_chain_from_parts(parts))
+        return nil unless type
+        return nil unless type.respond_to?(:fields) && type.fields
+
+        type.fields.keys
+      end
+
+      def comptime_folded_value?(value)
+        return false if value.nil?
+        return false if value.is_a?(Types::Base)
+
+        true
+      end
+
+      def comptime_const_function_return?(func)
+        func && func.respond_to?(:ast) && func.ast.respond_to?(:const) && func.ast.const
+      end
+
+      def comptime_const_method_body(binding, arguments, scopes:, receiver_value:)
+        method = binding.ast
+        return nil unless method.respond_to?(:body) && method.body
+        return nil if binding.type_params.any?
+        return nil unless method.params.length == arguments.length
+
+        initial_vars = {}
+        if binding.type.receiver_type
+          return nil unless comptime_folded_value?(receiver_value)
+
+          initial_vars["this"] = receiver_value
+        end
+
+        method.params.each_with_index do |param, idx|
+          arg_value = comptime_eval(arguments[idx].value, scopes)
+          return nil unless arg_value
+
+          initial_vars[param.name] = arg_value
+        end
+
+        variable_types = binding.body_params.each_with_object({}) do |param, acc|
+          acc[param.name] = param.type
+        end
+        block_context = comptime_block_context(initial_vars, variable_types)
+        result = block_context.evaluate_block(method.body, scopes: nil)
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
+      rescue CompileTime::Error => e
+        comptime_raise_error(e)
+      end
+
+      def comptime_imported_value_type(import_name, member)
+        imported_module = @ctx.imports.fetch(import_name, nil)
+        return nil unless imported_module
+
+        imported_module.values[member]&.type
+      end
+    end
+  end
+end

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/resolve.rb

@@ -3,6 +3,7 @@
 module MilkTea
   module Lowering
     module Resolve
+      include CompileTime::MethodFolding
       PASS_THROUGH_BUILTINS = {
         "fatal"         => :fatal,
         "ref_of"        => :ref_of,
@@ -1558,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:) },
                 ))
@@ -1573,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
 
@@ -1594,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"
@@ -1794,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
@@ -1816,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:)

data/lib/milk_tea/core/parser/declarations.rb

@@ -459,6 +459,7 @@ module MilkTea
         match(:async)
         match(:editable) if check(:editable)
         match(:static) if check(:static)
+        match(:const) if check(:const)
         result = check(:function) && !check_next(:colon)
         @current = saved
         result
@@ -657,10 +658,10 @@ module MilkTea
       end
 
       def parse_method_def(attributes: [])
-        visibility, _visibility_token, async, kind, line, name_token = parse_method_head
+        visibility, _visibility_token, async, kind, const, line, name_token = parse_method_head
         name = name_token.lexeme
         type_params, params, return_type, body = parse_callable_signature
-        AST::MethodDef.new(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes:, line:, column: name_token.column)
+        AST::MethodDef.new(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, const:, attributes:, line:, column: name_token.column)
       rescue ParseError => e
         raise unless @recovery_errors
 
@@ -668,11 +669,12 @@ module MilkTea
         name = name_token&.lexeme || "unknown"
         col = name_token&.column || 1
         advance until eof? || check(:function) || check(:dedent)
-        AST::MethodDef.new(name:, type_params: [], params: [], return_type: nil, body: nil, kind: kind || :plain, visibility: visibility || :private, async: async || false, attributes:, line:, column: col)
+        AST::MethodDef.new(name:, type_params: [], params: [], return_type: nil, body: nil, kind: kind || :plain, visibility: visibility || :private, async: async || false, const: const || false, attributes:, line:, column: col)
       end
 
       def parse_interface_method_decl(attributes: [])
-        visibility, visibility_token, async, kind, line, name_token = parse_method_head
+        visibility, visibility_token, async, kind, const, line, name_token = parse_method_head
+        raise error(name_token, "const is not allowed on interface methods") if const
         raise error(visibility_token, "public is not allowed on interface methods") if visibility == :public
 
         name = name_token.lexeme
@@ -689,6 +691,9 @@ module MilkTea
         visibility, visibility_token = parse_visibility
         async = match(:async)
         kind = parse_method_kind
+        const = match(:const)
+        raise error(previous, "editable methods cannot be const") if kind == :editable && const
+        raise error(previous, "async methods cannot be const") if async && const
         if check(:function)
           consume(:function, "expected function declaration")
         elsif check(:identifier)
@@ -699,7 +704,7 @@ module MilkTea
         end
         line = previous.line
         name_token = consume_name("expected function name")
-        [visibility, visibility_token, async, kind, line, name_token]
+        [visibility, visibility_token, async, kind, const, line, name_token]
       end
 
       def parse_method_kind

data/lib/milk_tea/core/pretty_printer/ast_formatter.rb

@@ -298,14 +298,16 @@ module MilkTea
 
       def render_function_signature(function, prefix: "")
         signature_prefix = if function.is_a?(AST::MethodDef)
-          case function.kind
-          when :editable
-            "editable function "
-          when :static
-            "static function "
-          else
-            "function "
-          end
+          kind_prefix = case function.kind
+                        when :editable
+                          "editable "
+                        when :static
+                          "static "
+                        else
+                          ""
+                        end
+          const_prefix = function.respond_to?(:const) && function.const ? "const " : ""
+          "#{kind_prefix}#{const_prefix}function "
         elsif function.is_a?(AST::ForeignFunctionDecl)
           "foreign function "
         else

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

@@ -298,6 +298,33 @@ module MilkTea
             current_type_params[identifier_expression.name] || @ctx.types[identifier_expression.name]
           end,
           resolve_member_access: lambda do |member_access_expression|
+            if (receiver_value = CompileTime.evaluate(
+                  member_access_expression.receiver,
+                  resolve_identifier: lambda do |identifier_expression|
+                    if scopes
+                      binding = lookup_value(identifier_expression.name, scopes)
+                      return binding.const_value unless binding&.const_value.nil?
+                    end
+
+                    resolve_current_module_const_value(identifier_expression.name)
+                  end,
+                  resolve_member_access: lambda { |ma| evaluate_compile_time_const_value(ma, scopes:) },
+                  resolve_type_ref: lambda { |tr| resolve_type_ref(tr) },
+                  resolve_call: lambda { |ce| evaluate_compile_time_call(ce, scopes:) },
+                ))
+              case receiver_value
+              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
+
             if member_access_expression.receiver.is_a?(AST::Identifier) && scopes
               binding = lookup_value(member_access_expression.receiver.name, scopes)
               if binding && binding.const_value
@@ -392,6 +419,11 @@ module MilkTea
             end
             return CompileTime::VariantValue.new(arm: arm_name, fields: fields)
           end
+
+          if (method_binding = comptime_method_binding(expression.callee, scopes))
+            receiver_value = comptime_member_receiver_value(expression.callee.receiver, scopes)
+            return comptime_const_method_body(method_binding, expression.arguments, scopes:, receiver_value:)
+          end
         when AST::Identifier
           if (struct_type = @ctx.types[expression.callee.name]) && struct_type.is_a?(Types::Struct)
             fields = {}
@@ -587,7 +619,10 @@ module MilkTea
           initial_vars[param.name] = arg_value
         end
 
-        ctx = CompileTime::BlockContext.new(self, initial_variables: initial_vars)
+        variable_types = func.body_params.each_with_object({}) do |param, acc|
+          acc[param.name] = param.type
+        end
+        ctx = CompileTime::BlockContext.new(self, 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
       rescue CompileTime::Error => e
@@ -613,6 +648,40 @@ module MilkTea
         end
       end
 
+      def comptime_methods_map
+        @ctx.methods
+      end
+
+      def comptime_methods_map_by_to_s(_type)
+        nil
+      end
+
+      def comptime_scoped_value_type(name, ctx)
+        return nil unless ctx
+
+        lookup_value(name, ctx)&.type
+      end
+
+      def comptime_value_type(name)
+        @ctx.top_level_values[name]&.type
+      end
+
+      def comptime_const_function(name)
+        @ctx.top_level_functions[name]
+      end
+
+      def comptime_eval(expression, scopes)
+        evaluate_compile_time_const_value(expression, scopes: scopes)
+      end
+
+      def comptime_block_context(initial_vars, variable_types)
+        ::MilkTea::CompileTime::BlockContext.new(self, initial_variables: initial_vars, variable_types: variable_types)
+      end
+
+      def comptime_raise_error(error)
+        raise_sema_error(error.message)
+      end
+
       def evaluate_has_attribute_call(arguments, scopes:)
         target = evaluate_reflection_target_argument(arguments.first.value, scopes:)
         binding = resolve_attribute_name_argument(arguments[1].value)

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -131,6 +131,7 @@ module MilkTea
 
     class Checker
       include Intrinsics
+      include CompileTime::MethodFolding
 
       attr_reader :ctx
 
@@ -222,8 +223,14 @@ module MilkTea
           when AST::WhenStmt
             body = when_chosen_body(decl)
             collect_emit_from_declarations(body) if body
-          when AST::StructDecl, AST::ExtendingBlock
-            # no emit in structs/extending blocks
+          when AST::StructDecl
+            # no emit in structs
+          when AST::ExtendingBlock
+            decl.methods.each do |method|
+              next unless method.respond_to?(:const) && method.const && method.body
+
+              collect_emit_from_statements(method.body)
+            end
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.43
+  version: 0.4.0
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -205,6 +205,7 @@ files:
 - lib/milk_tea/core/c_backend/type_declaration.rb
 - lib/milk_tea/core/c_backend/type_system.rb
 - lib/milk_tea/core/compile_time.rb
+- lib/milk_tea/core/compile_time/method_folding.rb
 - lib/milk_tea/core/control_flow.rb
 - lib/milk_tea/core/control_flow/builder.rb
 - lib/milk_tea/core/control_flow/constant_propagation.rb
@@ -628,7 +629,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.43 installed!
+  Milk Tea 0.4.0 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH