mt-lang 0.3.31 → 0.3.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16833c6b95c7e580f12199a381802f47ac628b7252f4bc1647714098cbd4f824
-  data.tar.gz: 296b0547096ceee9d394edc13df6f042e2b8ed6d42c98b4745e1b39885407b85
+  metadata.gz: d03b5daec92d1aeea437f63bd934696f684e524e76985470d416f0bea8d61002
+  data.tar.gz: f83f7c79a70a575e0827819865c75955be0c4c03bb6761570afc4bb0df1a75ff
 SHA512:
-  metadata.gz: '080aa9b4ad981dce767373642fe8c81fef77bf4b4c364b60e2b5dc633e7e1a2f593187ebcc3903a15aebec587bd6989a844dfd8fd842fb8b61fc855a5ba9ce86'
-  data.tar.gz: b9c60e1298c8fb8195401875f3d77358965741c1537cb674696d71ca1b5ef8f8ce5289d7a4e3491bbca24bd485481d6fd65df531a975237c08da888539c30b9e
+  metadata.gz: 7f30fbf67b0723afe3b16c14706b817c7b8adea64a0064cb2b7ecb0ff7935efab149a60eb84ced949bc7e6c5da922338d884ee20f1023a2f86ee78b47d2ee8c9
+  data.tar.gz: 4d879d9b77dce83a2900f04669c1d858f91c84d6cf101adedfce327b4a18be886f68425429e9dd630c00286d6f1ef53a2e97834ddcbaa30a79726cbe2c66193a

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/bindings/bindgen/emitter.rb

@@ -76,19 +76,12 @@ module MilkTea
           fields = Array(node["inner"]).select { |child| child["kind"] == "FieldDecl" }
           fields.each do |field|
             field_type = aggregate_field_type(field, owner_name: name, aggregate_node: node)
-            mt_name, = bindgen_field_name(emitted_name(aggregate_field_name(field, aggregate_node: node)))
+            mt_name = emitted_name(aggregate_field_name(field, aggregate_node: node))
             lines << "    #{mt_name}: #{field_type}"
           end
           lines
         end
 
-        def bindgen_field_name(name)
-          name = emitted_name(name)
-          return [name, nil] unless Token::KEYWORDS.key?(name)
-
-          ["#{name}_", nil]
-        end
-
         def bindgen_param_name(name)
           name = emitted_name(name)
           return [name, nil] unless generated_binding_name_conflict?(name)

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

@@ -324,7 +324,7 @@ module MilkTea
       newline_start = line_offset + line.length
       newline_end = has_newline ? (newline_start + 1) : newline_start
       if @grouping_depth.zero?
-        if Token::LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type)
+        if Token::LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type) && !trailing_is_member_access?
           @continuation_pending = true
         else
           @tokens << build_token(:newline, "\n", nil, line_number, line.length + 1, start_offset: newline_start, end_offset: newline_end)
@@ -345,6 +345,10 @@ module MilkTea
       1
     end
 
+    def trailing_is_member_access?
+      @tokens.last&.type == :is && @tokens[-2]&.type == :dot
+    end
+
     def emit_newline(line, line_number, line_offset, has_newline)
       newline_start = line_offset + line.bytesize
       newline_end = has_newline ? (newline_start + 1) : newline_start

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/parser/declarations.rb

@@ -454,7 +454,7 @@ module MilkTea
         match(:async)
         match(:editable) if check(:editable)
         match(:static) if check(:static)
-        result = check(:function)
+        result = check(:function) && !check_next(:colon)
         @current = saved
         result
       end
@@ -468,11 +468,13 @@ module MilkTea
 
         visibility, visibility_token = parse_visibility
 
-        if match(:event)
+        if check(:event) && !check_next(:colon)
+          advance
           return [:event, parse_event_decl(visibility:, attributes: field_attributes)]
         end
 
-        if match(:struct)
+        if check(:struct) && !check_next(:colon)
+          advance
           return [:nested_type, parse_struct_decl(visibility:, attributes: field_attributes, inline_methods: false)]
         end
 
@@ -741,7 +743,10 @@ module MilkTea
       end
 
       def parse_visibility
-        return [:public, previous] if match(:public)
+        if check(:public) && !check_next(:colon)
+          advance
+          return [:public, previous]
+        end
 
         [:private, nil]
       end

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