mt-lang 0.3.32 → 0.3.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0210a7132e7230d11f390c51bf60c7ff5a19b0d7716737b3ed5ac89b4a773842
-  data.tar.gz: 54d1170e9f9630b6747062b2ee8d285cb3b8cb83f5399469ba3b7908f81ad654
+  metadata.gz: 8d0786ef5ca9025e069a44b7ea3915199110e1f2397d294ed81122a308c79e2e
+  data.tar.gz: 42e3fa0077192377fa7da61cea865fd04e8ef49d66343c71a1bd5e2e1caa8b59
 SHA512:
-  metadata.gz: 2ca666aaa8bceb581fbe3a54c315127a3dbe3bb1a7a122027d9af44f96c3095d352d3f10f65f3e4d31b4992bca017eca600e7216c16a9a71ec81f1d0fb8091a7
-  data.tar.gz: 6d143563d49aae6636133feaa6bac2b0bee00e468d972c48db3d665692624341f4d5cbbe880fe9ba91aa0aec7da0c253df1facc5d4c405ddcd44778e67ca7ca9
+  metadata.gz: fd4a874279ff48b7d0f1de8baf092e92e01ede8a4c969133855c9dd9c9f061490c11ff29dfc24905466fe1df56d1d53a86a5c156ce1cbe5efeed60d78f5a21e8
+  data.tar.gz: 30bb123ddb1939f7694c62dae186152b8f592d78826e7b4aa416c6a010202d07bda5474b72014114d8064b7168ff02b6b7dd252a8b7d007d9b9bcae8b31b4786

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/compile_time.rb

@@ -437,7 +437,7 @@ module MilkTea
                 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,
+                resolve_call: ->(call_expr) { resolve_compile_time_call(call_expr, scopes:) },
               )
             end
             return nil unless arg_value

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

@@ -56,16 +56,10 @@ module MilkTea
       def build_statement(stmt, next_id, break_target:, continue_target:)
         case stmt
         when AST::LocalDecl
-          if stmt.else_body
-            reads, reads_info = read_identifiers_with_sites(stmt.value)
-            writes = Set.new
-            writes_info = []
-            declaration_key = declaration_binding_key(stmt, stmt.name)
-            if declaration_key && (stmt.value || @local_decl_without_initializer_writes)
-              writes << declaration_key
-              writes_info << { name: stmt.name, binding_key: declaration_key, line: stmt.line, column: stmt.column, origin: :declaration }
-            end
+          reads, reads_info = read_identifiers_with_sites(stmt.value)
+          writes, writes_info = local_decl_write_targets(stmt, stmt.name)
 
+          if stmt.else_body
             success_id = add_linear_node(:local_decl, stmt, next_id, writes:, writes_info:)
             null_entry = build_block(stmt.else_body, next_id, break_target:, continue_target:)
             condition_id = @graph.add_node(
@@ -80,14 +74,6 @@ module MilkTea
             return condition_id
           end
 
-          reads, reads_info = read_identifiers_with_sites(stmt.value)
-          writes = Set.new
-          writes_info = []
-          declaration_key = declaration_binding_key(stmt, stmt.name)
-          if declaration_key && (stmt.value || @local_decl_without_initializer_writes)
-            writes << declaration_key
-            writes_info << { name: stmt.name, binding_key: declaration_key, line: stmt.line, column: stmt.column, origin: :declaration }
-          end
           add_linear_node(:local_decl, stmt, next_id, reads:, reads_info:, writes:, writes_info:)
         when AST::Assignment
           reads, reads_info = read_identifiers_with_sites(stmt.value)
@@ -213,13 +199,10 @@ module MilkTea
           build_block(stmt.body, next_id, break_target:, continue_target:)
         when AST::DeferStmt
           body_entry = build_block(stmt.body, next_id, break_target:, continue_target:)
-          expression_reads, expression_reads_info = statement_list_reads_with_sites(stmt.body)
           defer_id = @graph.add_node(
             kind: :defer,
             statement: stmt,
             line: stmt.line,
-            reads: expression_reads,
-            reads_info: expression_reads_info,
           )
           @graph.add_edge(defer_id, body_entry)
           defer_id
@@ -315,66 +298,6 @@ module MilkTea
         [reads, reads_info]
       end
 
-      def statement_list_reads_with_sites(statements)
-        reads = Set.new
-        reads_info = []
-        statement_list_read_identifiers(statements, reads, reads_info)
-        [reads, reads_info]
-      end
-
-      def statement_list_read_identifiers(statements, reads, reads_info)
-        Array(statements).each do |statement|
-          statement_read_identifiers(statement, reads, reads_info)
-        end
-      end
-
-      def statement_read_identifiers(statement, reads, reads_info)
-        case statement
-        when AST::ExpressionStmt
-          read_identifiers(statement.expression, reads, reads_info)
-        when AST::DeferStmt
-          statement_list_read_identifiers(statement.body, reads, reads_info)
-        when AST::LocalDecl
-          read_identifiers(statement.value, reads, reads_info)
-          statement_list_read_identifiers(statement.else_body, reads, reads_info)
-        when AST::Assignment
-          read_identifiers(statement.target, reads, reads_info)
-          read_identifiers(statement.value, reads, reads_info)
-        when AST::ReturnStmt
-          read_identifiers(statement.value, reads, reads_info)
-        when AST::IfStmt
-          statement.branches.each do |branch|
-            read_identifiers(branch.condition, reads, reads_info)
-            statement_list_read_identifiers(branch.body, reads, reads_info)
-          end
-          statement_list_read_identifiers(statement.else_body, reads, reads_info)
-        when AST::WhileStmt
-          read_identifiers(statement.condition, reads, reads_info)
-          statement_list_read_identifiers(statement.body, reads, reads_info)
-        when AST::ForStmt
-          statement.iterables.each { |iterable| read_identifiers(iterable, reads, reads_info) }
-          statement_list_read_identifiers(statement.body, reads, reads_info)
-        when AST::UnsafeStmt
-          statement_list_read_identifiers(statement.body, reads, reads_info)
-        when AST::MatchStmt
-          read_identifiers(statement.expression, reads, reads_info)
-          statement.arms.each do |arm|
-            read_identifiers(arm.pattern, reads, reads_info)
-            statement_list_read_identifiers(arm.body, reads, reads_info)
-          end
-        when AST::StaticAssert
-          read_identifiers(statement.condition, reads, reads_info)
-          read_identifiers(statement.message, reads, reads_info)
-        when AST::WhenStmt
-          read_identifiers(statement.discriminant, reads, reads_info)
-          statement.branches.each do |branch|
-            read_identifiers(branch.pattern, reads, reads_info)
-            statement_list_read_identifiers(branch.body, reads, reads_info)
-          end
-          statement_list_read_identifiers(statement.else_body, reads, reads_info)
-        end
-      end
-
       def read_identifiers(expression, names = Set.new, reads_info = [])
         case expression
         when nil
@@ -582,6 +505,18 @@ module MilkTea
         name
       end
 
+      def local_decl_write_targets(stmt, name)
+        writes = Set.new
+        writes_info = []
+        declaration_key = declaration_binding_key(stmt, name)
+        if declaration_key && (stmt.value || @local_decl_without_initializer_writes)
+          writes << declaration_key
+          writes_info << { name:, binding_key: declaration_key, line: stmt.line, column: stmt.column, origin: :declaration }
+        end
+        write_targets_from_expression(stmt.value, line: stmt.line, writes:, writes_info:)
+        [writes, writes_info]
+      end
+
       def add_null_test_refinements(cond_id, true_succ, false_succ, condition)
         pairs = null_check_pairs(condition, positive: true)
         return if pairs.empty?

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

@@ -26,9 +26,9 @@ module MilkTea
 
           next if type == Types::BUILTIN_TYPE_META_TYPE
 
-          if const_value && (decl.value.is_a?(AST::Call) || decl.value.is_a?(AST::Specialization))
+          if !const_value.nil? && (decl.value.is_a?(AST::Call) || decl.value.is_a?(AST::Specialization))
             value = lower_const_value_literal(type, const_value)
-          elsif const_value && (decl.block_body || decl.value.is_a?(AST::ExpressionList))
+          elsif !const_value.nil? && (decl.block_body || decl.value.is_a?(AST::ExpressionList))
             if const_value.is_a?(Array) && const_value.empty? && decl.value.is_a?(AST::ExpressionList) && !decl.value.elements.empty?
               value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
             else
@@ -38,12 +38,46 @@ module MilkTea
             raise LoweringError.new("constant #{decl.name} has no compile-time value", line: decl.line, column: decl.column)
           else
             value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
+            if (decl.value.is_a?(AST::Call) || decl.value.is_a?(AST::Specialization)) && static_initializer_ir_has_call?(value)
+              raise LoweringError.new("constant #{decl.name} initializer is not a compile-time value", line: decl.line, column: decl.column, path: @ctx.current_analysis_path)
+            end
           end
 
           IR::Constant.new(name: decl.name, linkage_name: value_c_name(decl.name), type:, value:, line: decl.line, path: @ctx.current_analysis_path)
         end
       end
 
+      def static_initializer_ir_has_call?(node)
+        case node
+        when IR::Call
+          true
+        when IR::AggregateLiteral
+          node.fields.any? { |field| static_initializer_ir_has_call?(field.value) }
+        when IR::ArrayLiteral
+          node.elements.any? { |element| static_initializer_ir_has_call?(element) }
+        when IR::VariantLiteral
+          node.fields.any? { |field| static_initializer_ir_has_call?(field.value) }
+        when IR::Binary
+          static_initializer_ir_has_call?(node.left) || static_initializer_ir_has_call?(node.right)
+        when IR::Unary
+          static_initializer_ir_has_call?(node.operand)
+        when IR::Conditional
+          static_initializer_ir_has_call?(node.condition) || static_initializer_ir_has_call?(node.then_expression) || static_initializer_ir_has_call?(node.else_expression)
+        when IR::Cast
+          static_initializer_ir_has_call?(node.expression)
+        when IR::AddressOf
+          static_initializer_ir_has_call?(node.expression)
+        when IR::Member
+          static_initializer_ir_has_call?(node.receiver)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          static_initializer_ir_has_call?(node.receiver) || static_initializer_ir_has_call?(node.index)
+        when IR::ReinterpretExpr
+          static_initializer_ir_has_call?(node.expression)
+        else
+          false
+        end
+      end
+
       def lower_const_value_literal(type, const_value)
         case const_value
         when Integer

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

@@ -1323,10 +1323,10 @@ module MilkTea
           IR::FloatLiteral.new(value: expression.value, type:)
         when AST::SizeofExpr
           target_type = resolve_type_ref_with_fallback(expression.type, env:)
-          target_type ? IR::SizeofExpr.new(target_type:, type:) : raise(LoweringError, "size_of argument is not a concrete type")
+          target_type ? IR::SizeofExpr.new(target_type:, type:) : raise(LoweringError.new("size_of argument is not a concrete type", line: expression.line, column: expression.column, path: @ctx.current_analysis_path))
         when AST::AlignofExpr
           target_type = resolve_type_ref_with_fallback(expression.type, env:)
-          target_type ? IR::AlignofExpr.new(target_type:, type:) : raise(LoweringError, "align_of argument is not a concrete type")
+          target_type ? IR::AlignofExpr.new(target_type:, type:) : raise(LoweringError.new("align_of argument is not a concrete type", line: expression.line, column: expression.column, path: @ctx.current_analysis_path))
         when AST::OffsetofExpr
           target_type = resolve_type_ref(expression.type)
           if !@bypass_sema_type_cache && (precomputed = @ctx.const_values[@ctx.ast.node_ids[expression.object_id]])
@@ -1348,6 +1348,8 @@ module MilkTea
           binding = lookup_value(expression.name, env)
           if binding
             lower_bound_identifier(binding, expected_type:)
+          elsif (value_param = value_param_literal(expression.name, type))
+            value_param
           elsif @ctx.functions.key?(expression.name)
             function_binding = @ctx.functions.fetch(expression.name)
             raise LoweringError.new("generic function #{expression.name} cannot be used as a value", line: 0, column: 0, path: @ctx.current_analysis_path) if function_binding.type_params.any?
@@ -1699,13 +1701,24 @@ module MilkTea
         return unless expression
 
         ct_value = compile_time_const_value(expression, env:)
-        if ct_value.is_a?(Types::Struct) || ct_value.is_a?(Types::Primitive) ||
-            ct_value.is_a?(Types::Union) || ct_value.is_a?(Types::Nullable) ||
-            ct_value.is_a?(Types::StructInstance)
+        if sized_layout_ct_value?(ct_value)
           ct_value
         end
       end
 
+      def sized_layout_ct_value?(type)
+        case type
+        when Types::Primitive, Types::Struct, Types::StructInstance, Types::Union, Types::Enum, Types::Flags, Types::Variant, Types::Span, Types::StringView, Types::Task, Types::Event, Types::Subscription
+          true
+        when Types::Nullable
+          true
+        when Types::GenericInstance
+          pointer_type?(type) || array_type?(type) || str_buffer_type?(type)
+        else
+          false
+        end
+      end
+
       def build_expression_from_qualified_name(qualified_name)
         parts = qualified_name.parts
         return unless parts.length >= 1

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

@@ -117,7 +117,9 @@ module MilkTea
         env = empty_env
         parameter_setup = []
         previous_type_substitutions = @ctx.current_type_substitutions
+        previous_value_type_params = @ctx.current_value_type_params
         @ctx.current_type_substitutions = binding.type_substitutions
+        @ctx.current_value_type_params = resolve_value_type_params(decl.type_params)
 
         return lower_async_function_decl(binding, receiver_type:) if binding.async
 
@@ -176,6 +178,15 @@ module MilkTea
         )
       ensure
         @ctx.current_type_substitutions = previous_type_substitutions
+        @ctx.current_value_type_params = previous_value_type_params
+      end
+
+      def resolve_value_type_params(type_params)
+        type_params.each_with_object({}) do |type_param, map|
+          next unless type_param.is_a?(AST::ValueTypeParam)
+
+          map[type_param.name] = resolve_type_ref(type_param.type, type_params: current_type_params)
+        end
       end
 
       def lower_async_function_decl(binding, receiver_type: nil)

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

@@ -9,6 +9,7 @@ module MilkTea
       attr_accessor :methods, :attributes, :attribute_applications, :implemented_interfaces
       attr_accessor :struct_types, :union_types, :opaque_types
       attr_accessor :current_type_substitutions
+      attr_accessor :current_value_type_params
       attr_accessor :resolved_expr_types
       attr_accessor :resolved_call_kinds
       attr_accessor :const_values
@@ -27,6 +28,7 @@ module MilkTea
         @attribute_applications = {}
         @implemented_interfaces = {}
         @current_type_substitutions = nil
+        @current_value_type_params = nil
         @resolved_expr_types = {}
         @resolved_call_kinds = {}
         @const_values = {}

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

@@ -699,7 +699,7 @@ module MilkTea
       end
 
       def infer_expression_type(expression, env:, expected_type: nil)
-        if !@bypass_sema_type_cache && expected_type.nil? && (id = @ctx.ast.node_ids[expression.object_id]) && (resolved = @ctx.resolved_expr_types[id])
+        if !@bypass_sema_type_cache && expected_type.nil? && !expression.is_a?(AST::Identifier) && (id = @ctx.ast.node_ids[expression.object_id]) && (resolved = @ctx.resolved_expr_types[id])
           return resolved
         end
 
@@ -740,6 +740,9 @@ module MilkTea
         when AST::Identifier
           binding = lookup_value(expression.name, env)
           return binding[:type] if binding
+          if (value_param_type = value_param_declared_type(expression.name))
+            return value_param_type
+          end
             return function_type_for_name(expression.name) if @ctx.functions.key?(expression.name)
 
             raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column)
@@ -2437,6 +2440,25 @@ module MilkTea
         @ctx.current_type_substitutions || {}
       end
 
+      def value_param_substitution(name)
+        substitution = current_type_params[name]
+        substitution.is_a?(Types::LiteralTypeArg) ? substitution : nil
+      end
+
+      def value_param_declared_type(name)
+        return nil unless value_param_substitution(name)
+
+        @ctx.current_value_type_params&.[](name)
+      end
+
+      def value_param_literal(name, expected_type = nil)
+        substitution = value_param_substitution(name)
+        return nil unless substitution && substitution.value.is_a?(Integer)
+
+        type = @ctx.current_value_type_params&.[](name) || expected_type || @ctx.types.fetch("int")
+        IR::IntegerLiteral.new(value: substitution.value, type:)
+      end
+
       def resolve_type_ref(type_ref, type_params: current_type_params)
         if type_ref.is_a?(AST::FunctionType)
           params = type_ref.params.map do |param|

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

@@ -321,7 +321,25 @@ module MilkTea
           return literal
         end
 
-        lower_expression(rewrite_static_storage_initializer(expression), env:, expected_type: expected_type)
+        rewritten = rewrite_static_storage_initializer(expression)
+        if (imported_analysis = static_storage_imported_analysis(expression))
+          with_analysis_context(imported_analysis) do
+            lower_expression(rewritten, env:, expected_type: expected_type)
+          end
+        else
+          lower_expression(rewritten, env:, expected_type: expected_type)
+        end
+      end
+
+      def static_storage_imported_analysis(expression)
+        return nil unless expression.is_a?(AST::MemberAccess)
+        return nil unless expression.receiver.is_a?(AST::Identifier)
+        return nil unless @ctx.imports.key?(expression.receiver.name)
+
+        imported_module = @ctx.imports.fetch(expression.receiver.name)
+        return nil unless imported_module.values[expression.member]&.kind == :const
+
+        analysis_for_module(imported_module.name)
       end
 
       def lower_compile_time_literal(value, type)
@@ -337,6 +355,14 @@ module MilkTea
           if type == @ctx.types.fetch("str") || type == @ctx.types.fetch("cstr")
             return IR::StringLiteral.new(value:, type:, cstring: type == @ctx.types.fetch("cstr"))
           end
+        when Array
+          return nil unless array_type?(type)
+
+          element_type = type.arguments.first
+          elements = value.map { |element| lower_compile_time_literal(element, element_type) }
+          return nil if elements.any?(&:nil?)
+
+          IR::ArrayLiteral.new(type:, elements:)
         when Hash
           return nil unless type.is_a?(Types::Struct)
           fields = value.map do |name, field_value|

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

@@ -31,6 +31,7 @@ module MilkTea
           receiver_type = infer_lvalue_receiver(
             expression.receiver,
             scopes:,
+            allow_ref_identifier: true,
             allow_pointer_identifier: true,
             require_mutable_pointer: true,
             allow_span_param_identifier: true,
@@ -333,6 +334,10 @@ module MilkTea
           return binding.type
         end
 
+        if (value_param_type = current_value_type_params[expression.name])
+          return value_param_type
+        end
+
         if @ctx.top_level_functions.key?(expression.name)
           raise_sema_error("generic function #{expression.name} must be called") if @ctx.top_level_functions.fetch(expression.name).type_params.any?
 

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

@@ -615,6 +615,7 @@ module MilkTea
 
         previous_type_substitutions = @current_type_substitutions
         previous_specialization_owner = @current_specialization_owner
+        previous_value_type_params = @current_value_type_params
         started_check = false
         return if binding.external
         return if @checked_function_bindings[binding.object_id]
@@ -624,6 +625,7 @@ module MilkTea
         started_check = true
         @current_type_substitutions = binding.type_substitutions
         @current_specialization_owner = binding.specialization_owner
+        @current_value_type_params = resolve_value_type_params(binding.ast.type_params)
         with_error_node(binding.ast) do
           with_scope(binding.body_params) do |scopes|
             start_local_completion_frame(binding, scopes)
@@ -678,8 +680,21 @@ module MilkTea
         @nullability_flow_result = nil
         @current_type_substitutions = previous_type_substitutions
         @current_specialization_owner = previous_specialization_owner
+        @current_value_type_params = previous_value_type_params
         @checking_function_bindings.delete(binding.object_id)
       end
+
+      def resolve_value_type_params(type_params)
+        type_params.each_with_object({}) do |type_param, map|
+          next unless type_param.is_a?(AST::ValueTypeParam)
+
+          map[type_param.name] = resolve_type_ref(
+            type_param.type,
+            type_params: current_type_params,
+            type_param_constraints: current_type_param_constraints,
+          )
+        end
+      end
     end
   end
 end

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

@@ -7,6 +7,10 @@ module MilkTea
         @current_type_substitutions || {}
       end
 
+      def current_value_type_params
+        @current_value_type_params || {}
+      end
+
       def current_type_param_constraints
         @current_type_param_constraints || {}
       end
@@ -463,9 +467,13 @@ module MilkTea
                   resolve_imported_module_const_value(type_ref.name.parts.first, type_ref.name.parts.last)
                 end
 
-        return unless value.is_a?(Integer) || value.is_a?(Float)
+        return if value.nil?
+        return Types::LiteralTypeArg.new(value) if value.is_a?(Integer) || value.is_a?(Float)
+        return value if value.is_a?(Types::Base)
 
-        Types::LiteralTypeArg.new(value)
+        nil
+      rescue SemanticError
+        nil
       end
 
       def resolve_current_module_const_value(name)
@@ -657,12 +665,8 @@ module MilkTea
         return false unless expression
 
         ct_value = evaluate_compile_time_const_value(expression, scopes:)
-        if ct_value.is_a?(Types::Struct) || ct_value.is_a?(Types::Primitive) ||
-           ct_value.is_a?(Types::Union) || ct_value.is_a?(Types::Nullable) ||
-           ct_value.is_a?(Types::StructInstance)
-          if sized_layout_type?(ct_value)
-            return true
-          end
+        if sized_layout_type?(ct_value)
+          return true
         end
 
         false

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

@@ -184,6 +184,23 @@ module MilkTea
         !binding.external && binding.type_params.empty?
       end
 
+      def predeclare_top_level_consts
+        @ctx.ast.declarations.each do |decl|
+          next unless decl.is_a?(AST::ConstDecl)
+
+          @ctx.const_declarations[decl.name] ||= decl
+          next if @ctx.top_level_values.key?(decl.name)
+
+          @ctx.top_level_values[decl.name] = value_binding(
+            name: decl.name,
+            type: @error_type,
+            mutable: false,
+            kind: :const,
+          )
+          @predeclared_const_names << decl.name
+        end
+      end
+
       def finalize_top_level_const_values
         @ctx.const_declarations.each_key { |name| evaluate_top_level_const_value(name) }
       end
@@ -247,7 +264,7 @@ module MilkTea
           kind: binding.kind,
           const_value: value,
         )
-        @evaluated_const_values[name] = true
+        @evaluated_const_values[name] = true unless value.nil?
       end
 
       def evaluate_compile_time_block(statements, scopes: nil)
@@ -261,6 +278,10 @@ module MilkTea
       end
 
       def evaluate_compile_time_const_value(expression, scopes: nil)
+        if (type_value = evaluate_type_constructor_index_access(expression, scopes:))
+          return type_value
+        end
+
         CompileTime.evaluate(
           expression,
           resolve_identifier: lambda do |identifier_expression|
@@ -324,6 +345,26 @@ module MilkTea
         raise_sema_error(e.message)
       end
 
+      def evaluate_type_constructor_index_access(expression, scopes:)
+        return nil unless expression.is_a?(AST::IndexAccess)
+        return nil unless expression.receiver.is_a?(AST::Identifier)
+        return nil unless expression.index.is_a?(AST::Identifier)
+        return nil unless %w[ptr const_ptr array span own ref].include?(expression.receiver.name)
+
+        type_ref = AST::TypeRef.new(
+          name: AST::QualifiedName.new(parts: [expression.index.name]),
+          arguments: [],
+          nullable: false,
+        )
+        specialization = AST::Specialization.new(
+          callee: expression.receiver,
+          arguments: [AST::TypeArgument.new(value: type_ref)],
+        )
+        evaluate_type_returning_call(specialization, scopes:)
+      rescue SemanticError
+        nil
+      end
+
       def evaluate_compile_time_call(expression, scopes: nil)
         case expression.callee
         when AST::MemberAccess
@@ -431,9 +472,31 @@ module MilkTea
                 end
                 return fields
               end
+              if resolved_type && array_type?(resolved_type)
+                values = []
+                expression.arguments.each do |argument|
+                  val = CompileTime.evaluate(argument.value, resolve_identifier: lambda { |id|
+                    if scopes
+                      binding = lookup_value(id.name, scopes)
+                      return binding.const_value unless binding&.const_value.nil?
+                    end
+                    resolve_current_module_const_value(id.name)
+                  }, resolve_member_access: lambda { |ma|
+                    if (receiver_type = resolve_type_expression(ma.receiver))
+                      next resolve_enum_member_const_value(receiver_type, ma.member)
+                    end
+                    nil
+                  }, resolve_call: lambda { |inner_call|
+                    evaluate_compile_time_call(inner_call, scopes:)
+                  })
+                  return nil unless val
+                  values << val
+                end
+                return values
+              end
               func = @ctx.top_level_functions[callee_name]
               if func&.ast&.respond_to?(:const) && func.ast.const
-                evaluate_const_function_body(func, expression.arguments, scopes:)
+                evaluate_const_function_body(func, expression.arguments, scopes:, type_args: expression.callee.arguments)
               else
                 evaluate_type_returning_call(expression, scopes:)
               end
@@ -453,7 +516,7 @@ module MilkTea
         CompileTime::Reflection.core_evaluate_type_returning(
           callee_name, type_args,
           evaluate_value: ->(v) { evaluate_compile_time_const_value(v, scopes:) },
-          resolve_type_ref: ->(tr) { resolve_type_ref(tr) },
+          resolve_type_ref: ->(tr) { resolve_named_literal_type_argument(tr) || resolve_type_ref(tr) },
           pointer_to: ->(t) { pointer_to(t) },
           const_pointer_to: ->(t) { const_pointer_to(t) },
           top_level_functions: ->(name) { @ctx.top_level_functions[name] },
@@ -484,7 +547,11 @@ module MilkTea
           when AST::IntegerLiteral
             initial_vars[param.name] = arg_value.value
           when AST::TypeRef
-            initial_vars[param.name] = resolve_type_ref(arg_value)
+            if (literal = resolve_named_literal_type_argument(arg_value))
+              initial_vars[param.name] = literal.value
+            else
+              initial_vars[param.name] = resolve_type_ref(arg_value)
+            end
           else
             return nil
           end
@@ -498,10 +565,11 @@ module MilkTea
         raise_sema_error(e.message)
       end
 
-      def evaluate_const_function_body(func, arguments, scopes:)
+      def evaluate_const_function_body(func, arguments, scopes:, type_args: nil)
         return nil unless func.ast.params.length == arguments.length
 
         initial_vars = {}
+        bind_const_function_value_type_params(func, type_args, initial_vars)
         func.ast.params.each_with_index do |param, idx|
           arg_expr = arguments[idx].value
           arg_value = if scopes
@@ -528,6 +596,25 @@ module MilkTea
         raise_sema_error(e.message)
       end
 
+      def bind_const_function_value_type_params(func, type_args, initial_vars)
+        value_params = func.ast.type_params.select { |p| p.is_a?(AST::ValueTypeParam) }
+        return if value_params.empty? || type_args.nil?
+
+        value_params.zip(type_args).each do |param, arg|
+          arg_value = arg.value
+          case arg_value
+          when AST::IntegerLiteral
+            initial_vars[param.name] = arg_value.value
+          when AST::TypeRef
+            if (literal = resolve_named_literal_type_argument(arg_value))
+              initial_vars[param.name] = literal.value
+            else
+              initial_vars[param.name] = resolve_type_ref(arg_value)
+            end
+          end
+        end
+      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/type_declaration.rb

@@ -726,6 +726,8 @@ module MilkTea
 
       def ensure_available_value_name!(name, kind_label: "value", line: nil, column: nil, length: nil)
         ensure_non_reserved_value_type_name!(name, kind_label:, line:, column:, length:)
+        return if @predeclared_const_names.delete?(name)
+
         raise_sema_error("duplicate value #{name}") if @ctx.top_level_values.key?(name) || @ctx.top_level_functions.key?(name)
       end
 
@@ -762,6 +764,7 @@ module MilkTea
                   type: type,
                   mutable: false,
                   kind: :const,
+                  const_value: @ctx.top_level_values[decl.name]&.const_value,
                 )
               rescue SemanticError => e
                 collect_structural_error(e)
@@ -770,6 +773,7 @@ module MilkTea
                   type: @error_type,
                   mutable: false,
                   kind: :const,
+                  const_value: @ctx.top_level_values[decl.name]&.const_value,
                 ) unless @ctx.top_level_values.key?(decl.name)
               end
             when AST::VarDecl

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -175,6 +175,7 @@ module MilkTea
         @mutable_lvalue_argument_identifier_ids = {}
         @editable_receiver_expression_ids = {}
         @preassigned_local_binding_ids = {}
+        @predeclared_const_names = Set.new
         @nullability_flow_result = nil
         @unsafe_statement_lines = []
         @callable_value_identifier_sites = {}
@@ -196,6 +197,7 @@ module MilkTea
         run_phase(:resolve_generic_type_param_constraints, requires: [:declare_named_types])
         run_phase(:resolve_type_aliases, requires: [:declare_named_types])
         run_phase(:declare_attributes)
+        run_phase(:predeclare_top_level_consts)
         run_phase(:resolve_aggregate_fields, requires: [:resolve_type_aliases, :declare_named_types])
         run_phase(:resolve_enum_members, requires: [:declare_named_types])
         run_phase(:resolve_variant_arms, requires: [:declare_named_types])
@@ -260,12 +262,16 @@ module MilkTea
           when AST::WhenStmt
             body = when_chosen_body(stmt) || []
             body.each { |nested| collect_emit_from_statements([nested]) }
-          when AST::ForStmt, AST::WhileStmt, AST::IfStmt, AST::MatchStmt
+          when AST::ForStmt, AST::WhileStmt
             next unless stmt.inline
             stmt.body&.each { |s| collect_emit_from_statements([s]) }
-            if stmt.is_a?(AST::IfStmt)
-              stmt.else_body&.each { |s| collect_emit_from_statements([s]) }
-            end
+          when AST::IfStmt
+            next unless stmt.inline
+            stmt.branches.each { |branch| collect_emit_from_statements(branch.body) }
+            stmt.else_body&.each { |s| collect_emit_from_statements([s]) }
+          when AST::MatchStmt
+            next unless stmt.inline
+            stmt.arms.each { |arm| collect_emit_from_statements(arm.body) }
           end
         end
       end
@@ -302,6 +308,7 @@ module MilkTea
         run_collecting_phase(:resolve_generic_type_param_constraints, requires: [:declare_named_types])
         run_collecting_phase(:resolve_type_aliases, requires: [:declare_named_types])
         run_collecting_phase(:declare_attributes)
+        run_collecting_phase(:predeclare_top_level_consts)
         run_collecting_phase(:resolve_aggregate_fields, requires: [:resolve_type_aliases, :declare_named_types])
         run_collecting_phase(:resolve_enum_members, requires: [:declare_named_types])
         run_collecting_phase(:resolve_variant_arms, requires: [:declare_named_types])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.32
+  version: 0.3.34
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -624,7 +624,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.32 installed!
+  Milk Tea 0.3.34 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH