mt-lang 0.3.16 → 0.3.20

data/lib/milk_tea/core/compile_time.rb

@@ -1,6 +1,185 @@
 # frozen_string_literal: true
 
-require_relative "compile_time/const_eval"
+require_relative "types/layout"
+
+module MilkTea
+  module ConstEval
+
+    def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
+      Evaluator.new(
+        resolve_identifier:,
+        resolve_member_access:,
+        resolve_type_ref:,
+        resolve_call:,
+      ).evaluate(expression)
+    end
+
+    def self.equality_result(left, right)
+      return left == right if left.is_a?(Numeric) && right.is_a?(Numeric)
+      return left == right if left.is_a?(String) && right.is_a?(String)
+      return left == right if boolean_value?(left) && boolean_value?(right)
+      return left == right if left.is_a?(Types::Base) && right.is_a?(Types::Base)
+
+      nil
+    end
+
+    def self.boolean_value?(value)
+      value == true || value == false
+    end
+
+    class Evaluator
+      def initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
+        @resolve_identifier = resolve_identifier
+        @resolve_member_access = resolve_member_access
+        @resolve_type_ref = resolve_type_ref
+        @resolve_call = resolve_call
+      end
+
+      def evaluate(expression)
+        case expression
+        when AST::ErrorExpr
+          nil
+        when AST::ExpressionList
+          expression.elements.filter_map { |element| evaluate(element) }
+        when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
+          expression.value
+        when AST::StringLiteral
+          expression.value
+        when AST::Identifier
+          @resolve_identifier&.call(expression)
+        when AST::MemberAccess
+          @resolve_member_access&.call(expression)
+        when AST::Call
+          @resolve_call&.call(expression)
+        when AST::Specialization
+          @resolve_call&.call(expression)
+        when AST::SizeofExpr
+          type = resolve_layout_type(expression.type)
+          type && Layout.size_of(type)
+        when AST::AlignofExpr
+          type = resolve_layout_type(expression.type)
+          type && Layout.alignment_of(type)
+        when AST::OffsetofExpr
+          type = resolve_layout_type(expression.type)
+          if type
+            result = Layout.offset_of(type, expression.field)
+            return result if result
+
+            id_expr = AST::Identifier.new(name: expression.field)
+            value = @resolve_identifier&.call(id_expr)
+            if value.is_a?(Types::FieldHandle)
+              return Layout.offset_of(type, value.field_name)
+            end
+          end
+          nil
+        when AST::UnaryOp
+          evaluate_unary(expression)
+        when AST::BinaryOp
+          evaluate_binary(expression)
+        when AST::IfExpr
+          condition = evaluate(expression.condition)
+          return unless ConstEval.boolean_value?(condition)
+
+          evaluate(condition ? expression.then_expression : expression.else_expression)
+        else
+          nil
+        end
+      end
+
+      def resolve_layout_type(type_ref)
+        return unless @resolve_type_ref
+
+        @resolve_type_ref.call(type_ref)
+      end
+
+      def evaluate_unary(expression)
+        operand = evaluate(expression.operand)
+
+        case expression.operator
+        when "+"
+          operand.is_a?(Numeric) ? operand : nil
+        when "-"
+          operand.is_a?(Numeric) ? -operand : nil
+        when "~"
+          operand.is_a?(Integer) ? ~operand : nil
+        when "not"
+          ConstEval.boolean_value?(operand) ? !operand : nil
+        end
+      end
+
+      def evaluate_binary(expression)
+        left = evaluate(expression.left)
+
+        case expression.operator
+        when "and"
+          return unless ConstEval.boolean_value?(left)
+          return false if left == false
+
+          right = evaluate(expression.right)
+          return right if ConstEval.boolean_value?(right)
+
+          return nil
+        when "or"
+          return unless ConstEval.boolean_value?(left)
+          return true if left == true
+
+          right = evaluate(expression.right)
+          return right if ConstEval.boolean_value?(right)
+
+          return nil
+        end
+
+        right = evaluate(expression.right)
+
+        case expression.operator
+        when "=="
+          ConstEval.equality_result(left, right)
+        when "!="
+          result = ConstEval.equality_result(left, right)
+          result.nil? ? nil : !result
+        when "+"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
+        when "-"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
+        when "*"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
+        when "/"
+          return unless left.is_a?(Numeric) && right.is_a?(Numeric)
+          raise CompileTime::Error, "division by zero" if zero_numeric?(right)
+
+          left / right
+        when "%"
+          return unless left.is_a?(Integer) && right.is_a?(Integer)
+          raise CompileTime::Error, "modulo by zero" if right.zero?
+
+          left % right
+        when "<<"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left << right : nil
+        when ">>"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left >> right : nil
+        when "&"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left & right : nil
+        when "|"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left | right : nil
+        when "^"
+          left.is_a?(Integer) && right.is_a?(Integer) ? left ^ right : nil
+        when "<"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left < right : nil
+        when "<="
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left <= right : nil
+        when ">"
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left > right : nil
+        when ">="
+          left.is_a?(Numeric) && right.is_a?(Numeric) ? left >= right : nil
+        end
+      end
+
+      def zero_numeric?(value)
+        (value.is_a?(Integer) && value.zero?) || (value.is_a?(Float) && value.zero?)
+      end
+    end
+  end
+end
 
 module MilkTea
   module CompileTime
@@ -73,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
@@ -256,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)
@@ -276,7 +482,6 @@ module MilkTea
         nil
       end
 
-
     end
 
     def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
@@ -354,4 +559,4 @@ module MilkTea
       end
     end
   end
-end
+end

data/lib/milk_tea/core/control_flow/constant_propagation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../compile_time/const_eval"
+require_relative "../compile_time"
 
 module MilkTea
   module ControlFlow

data/lib/milk_tea/core/{compatibility_helpers.rb → intrinsics.rb}

@@ -3,7 +3,7 @@
 require_relative "types/predicates"
 
 module MilkTea
-  module CompatibilityHelpers
+  module Intrinsics
     include Types::Predicates
 
     BUILTIN_CSTR = Types::Registry.primitive("cstr")
@@ -45,6 +45,13 @@ module MilkTea
       "with" => :simd_lane_with,
     }.freeze
 
+    SPECIALIZED_RECEIVERS = {
+      "str_buffer" => { predicate: :str_buffer_type?, kinds: STR_BUFFER_METHOD_KINDS },
+      "event"      => { predicate: :event_type?,      kinds: EVENT_METHOD_KINDS },
+      "atomic"     => { predicate: :atomic_type?,     kinds: ATOMIC_METHOD_KINDS },
+      "simd"       => { predicate: :simd_type?,       kinds: SIMD_METHOD_KINDS },
+    }.freeze
+
     def type_ref_from_specialization(expression)
       case expression.callee
       when AST::Identifier
@@ -78,4 +85,4 @@ module MilkTea
       expression.is_a?(AST::StringLiteral) && !expression.cstring && expected_type == BUILTIN_CSTR
     end
   end
-end
+end

data/lib/milk_tea/core/lexer.rb

@@ -106,6 +106,16 @@ module MilkTea
     BIN_DIGIT_BYTE = Array.new(256) { |b| b.chr.match?(/[01_]/) }.freeze
     SPACE_BYTE = " ".ord
 
+    include CharacterClasses
+    include Trivia
+    include Indentation
+    include Numbers
+    include Strings
+    include Heredocs
+    include FormatStrings
+    include Symbols
+    include Recovery
+
     def self.lex(source, path: nil, mode: :syntax_only, recovery_errors: nil)
       result = new(source, path: path, mode:, recovery_errors:).lex
       mode == :with_trivia ? result.tokens : result
@@ -170,16 +180,6 @@ module MilkTea
       @tokens
     end
 
-    include CharacterClasses
-    include Trivia
-    include Indentation
-    include Numbers
-    include Strings
-    include Heredocs
-    include FormatStrings
-    include Symbols
-    include Recovery
-
     def lex_line(lines, line_index, line, line_number, line_offset, has_newline:)
       tab_index = line.index("\t")
       if tab_index
@@ -279,43 +279,17 @@ module MilkTea
           break
         end
 
-        if char == "c" && heredoc_start?(line, index, cstring: true)
-          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: true)
-        end
-
-        if char == "c" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-          error = LexError.new("expected '<<-' for heredoc string; did you mean 'c<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
-          if @recovery_errors
-            @recovery_errors << error
-          else
-            raise error
+        if (char == "c" || char == "f")
+          result = dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+          if result
+            if result[0] == :return
+              return result[1]
+            else
+              index = result[1]
+              next
+            end
           end
         end
-        if char == "c" && line[index + 1] == '"'
-          result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
-          return result.consumed_lines if result.consumed_lines > 1
-
-          index = result.next_index
-          next
-        end
-
-        if char == "f" && heredoc_start?(line, index, format: true)
-          return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false, format: true)
-        end
-
-        if char == "f" && line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
-          error = LexError.new("expected '<<-' for heredoc string; did you mean 'f<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
-          if @recovery_errors
-            @recovery_errors << error
-          else
-            raise error
-          end
-        end
-
-        if char == "f" && line[index + 1] == '"'
-          index = lex_format_string(line, index, line_number, line_offset:)
-          next
-        end
 
         if char == "<" && heredoc_start?(line, index)
           return lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: false)
@@ -371,8 +345,6 @@ module MilkTea
       1
     end
 
-    # ── newline emission ────────────────────────────────────────────
-
     def emit_line_newline(line, line_number, line_offset, has_newline)
       newline_start = line_offset + line.bytesize
       newline_end = has_newline ? (newline_start + 1) : newline_start
@@ -393,7 +365,42 @@ module MilkTea
       end
     end
 
-    # ── token construction ──────────────────────────────────────────
+    def dispatch_cf_prefix(char, line, index, line_number, line_offset, lines:, line_index:)
+      return nil unless char == "c" || char == "f"
+
+      is_c = char == "c"
+      is_f = char == "f"
+
+      if heredoc_start?(line, index, cstring: is_c, format: is_f)
+        n = lex_heredoc(lines, line_index, index, line_number, line_offset, cstring: is_c, format: is_f)
+        return [:return, n]
+      end
+
+      if line[index + 1] == "<" && line[index + 2] == "-" && identifier_start?(line[index + 3])
+        error = LexError.new("expected '<<-' for heredoc string; did you mean '#{char}<<-#{identifier_start_token(line, index + 3)}'?", line: line_number, column: index + 1, path: @path)
+        if @recovery_errors
+          @recovery_errors << error
+        else
+          raise error
+        end
+        return nil
+      end
+
+      if line[index + 1] == '"'
+        if is_c
+          string_result = lex_string(lines, line_index, line, index, line_number, line_offset:, cstring: true)
+          if string_result.consumed_lines > 1
+            return [:return, string_result.consumed_lines]
+          end
+          return [:next, string_result.next_index]
+        end
+
+        new_index = lex_format_string(line, index, line_number, line_offset:)
+        return [:next, new_index]
+      end
+
+      nil
+    end
 
     def token(type, lexeme, literal, line, column, start_offset:, end_offset:)
       Token.new(

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

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "expressions"
+require_relative "loops"
+require_relative "proc"
+require_relative "resolve"
+require_relative "utils"
+require_relative "foreign_cstr"
+require_relative "declarations"
+require_relative "calls"
+
 module MilkTea
   module LowererBlock
     def lower_block(statements, env:, active_defers:, return_type:, loop_flow:, allow_return: true)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "dyn"
+
 module MilkTea
   module LowererCalls
     def lower_call(expression, env:, type:)

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

@@ -78,7 +78,7 @@ module MilkTea
         end
         IR::AggregateLiteral.new(type:, fields:)
       else
-        IR::IntegerLiteral.new(value: 0, type:)
+        raise LoweringError.new("unsupported const value type #{const_value.class}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
     end
 

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

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "resolve"
+require_relative "utils"
+require_relative "block"
+require_relative "async/normalization"
+require_relative "async/lowering"
+
 module MilkTea
   module LowererFunctions
     def lower_functions
       lowered = []
+      cursor = 0
+      declarations = @ctx.ast.declarations
 
-      changed = true
-      while changed
-        changed = false
-
+      while cursor < declarations.length
         expanded_declarations.each do |decl|
           case decl
           when AST::FunctionDef
@@ -21,7 +26,6 @@ module MilkTea
 
                 lowered << lower_function_decl(instance)
                 @artifacts.lowered_function_linkage_names[linkage_name] = true
-                changed = true
               end
             else
               linkage_name = function_binding_c_name(binding, module_name: @ctx.module_name)
@@ -37,7 +41,6 @@ module MilkTea
                   @artifacts.lowered_function_linkage_names[entrypoint.linkage_name] = true
                 end
               end
-              changed = true
             end
           when AST::ExtendingBlock
             receiver_type = resolve_extending_receiver_type(@ctx.analysis, decl.type_name)
@@ -56,7 +59,6 @@ module MilkTea
 
                   lowered << lower_function_decl(instance, receiver_type:)
                   @artifacts.lowered_function_linkage_names[linkage_name] = true
-                  changed = true
                 end
               else
                 linkage_name = function_binding_c_name(binding, module_name: @ctx.module_name, receiver_type:)
@@ -64,11 +66,12 @@ module MilkTea
 
                 lowered << lower_function_decl(binding, receiver_type:)
                 @artifacts.lowered_function_linkage_names[linkage_name] = true
-                changed = true
               end
             end
           end
         end
+
+        cursor = declarations.length
       end
 
       lowered

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

@@ -1518,12 +1518,19 @@ module MilkTea
     def resolve_type_argument_ref(type_ref, type_params:)
       return resolve_type_ref(type_ref, type_params:) unless literal_type_argument_name_candidate?(type_ref)
 
-      resolve_type_ref(type_ref, type_params:)
-    rescue LoweringError => error
+      result = try_resolve_type_ref(type_ref, type_params:)
+      return result if result
+
       literal_type_argument = resolve_named_literal_type_argument(type_ref)
       return literal_type_argument if literal_type_argument
 
-      raise error
+      resolve_type_ref(type_ref, type_params:)
+    end
+
+    def try_resolve_type_ref(type_ref, type_params:)
+      resolve_type_ref(type_ref, type_params:)
+    rescue LoweringError
+      nil
     end
 
     def literal_type_argument_name_candidate?(type_ref)