mt-lang 0.3.4 → 0.3.5

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

@@ -39,50 +39,6 @@ module MilkTea
         callee.is_a?(AST::MemberAccess) ? callee.member : nil
       end
 
-      def async_variant_match_arm_binding(arm, scrutinee_expr, scrutinee_type, env:, frame_expr: nil, local_fields: nil)
-        arm_env = duplicate_env(env)
-        binding_decl = nil
-
-        if arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
-          arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-          if arm_name && scrutinee_type.has_payload?(arm_name)
-            fields = scrutinee_type.arm(arm_name)
-            payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
-
-            field_key = async_match_binding_field_key(arm)
-            field_info = local_fields&.fetch(field_key, nil)
-            if field_info && frame_expr
-              target = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
-              binding_c = async_frame_field_c_name(field_info[:field_name])
-              arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: false, pointer: false)
-              data_expr = IR::Member.new(receiver: scrutinee_expr, member: "data", type: nil)
-              arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-              binding_decl = IR::Assignment.new(target:, operator: "=", value: arm_expr)
-            else
-              data_expr = IR::Member.new(receiver: scrutinee_expr, member: "data", type: nil)
-              arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-              binding_c = c_local_name(arm.binding_name)
-              arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: false, pointer: false)
-              binding_decl = IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_type, value: arm_expr)
-            end
-          end
-        end
-
-        [arm_env, binding_decl]
-      end
-
-      def bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
-        return unless scrutinee_type.is_a?(Types::Variant)
-        return unless arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
-
-        arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-        return unless arm_name && scrutinee_type.has_payload?(arm_name)
-
-        fields = scrutinee_type.arm(arm_name)
-        payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
-        arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: c_local_name(arm.binding_name), mutable: true, pointer: false)
-      end
-
       def array_type?(type)
         type.is_a?(Types::GenericInstance) && type.name == "array" && type.arguments.length == 2 &&
           type.arguments[1].is_a?(Types::LiteralTypeArg)
@@ -213,56 +169,6 @@ module MilkTea
         super
       end
 
-      def iterator_loop_info(type, env:)
-        iter_name = "__mt_for_iterable__"
-        iterator_name = "__mt_for_iterator__"
-        probe_env = duplicate_env(env)
-        current_actual_scope(probe_env[:scopes])[iter_name] = local_binding(type:, linkage_name: iter_name, mutable: false, pointer: false)
-
-        iter_call = AST::Call.new(
-          callee: AST::MemberAccess.new(receiver: AST::Identifier.new(name: iter_name), member: "iter"),
-          arguments: [],
-        )
-        iterator_type = infer_expression_type(iter_call, env: probe_env)
-
-        current_actual_scope(probe_env[:scopes])[iterator_name] = local_binding(type: iterator_type, linkage_name: iterator_name, mutable: true, pointer: false)
-        next_call = AST::Call.new(
-          callee: AST::MemberAccess.new(receiver: AST::Identifier.new(name: iterator_name), member: "next"),
-          arguments: [],
-        )
-        item_storage_type = infer_expression_type(next_call, env: probe_env)
-        if item_storage_type.is_a?(Types::Nullable) && nullable_iterator_item_type?(item_storage_type.base)
-          return {
-            kind: :nullable_item,
-            iterator_type:,
-            item_storage_type:,
-            item_type: item_storage_type.base,
-          }
-        end
-
-        if item_storage_type == @ctx.types.fetch("bool")
-          current_call = AST::Call.new(
-            callee: AST::MemberAccess.new(receiver: AST::Identifier.new(name: iterator_name), member: "current"),
-            arguments: [],
-          )
-          current_type = infer_expression_type(current_call, env: probe_env)
-          return {
-            kind: :current_item,
-            iterator_type:,
-            item_storage_type: current_type,
-            item_type: current_type,
-          }
-        end
-
-        nil
-      rescue LoweringError
-        nil
-      end
-
-      def nullable_iterator_item_type?(type)
-        type == @ctx.types.fetch("cstr") || pointer_type?(type)
-      end
-
       def collection_loop_item_value(iterable_ref, iterable_type, index_ref, element_type)
         if array_type?(iterable_type)
           IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
@@ -841,18 +747,6 @@ module MilkTea
         end
       end
 
-      def lower_async_loop_exit(target, local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
-        cleanup = lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
-        if cleanup.empty?
-          [loop_exit_statement(target, local_defers:, outer_defers:)]
-        else
-          label = target[:label]
-          raise LoweringError, "structured loop exits with cleanup are unsupported" unless label
-
-          cleanup + [IR::GotoStmt.new(label:)]
-        end
-      end
-
       def contains_label_target?(statements, label)
         statements.any? do |statement|
           case statement
@@ -928,28 +822,6 @@ module MilkTea
         !let_else_discard_binding_syntax?(statement)
       end
 
-      def async_local_decl_field_key(statement)
-        return "__discard_#{statement.line}" if statement.name == "_"
-
-        statement.name
-      end
-
-      def async_local_decl_field_name(statement)
-        return "local_discard_#{statement.line}" if statement.name == "_"
-
-        "local_#{statement.name}"
-      end
-
-      def async_match_binding_field_key(arm)
-        @async_binding_counter ||= 0
-        @async_binding_counter += 1
-        "match_binding_#{@async_binding_counter}"
-      end
-
-      def async_match_binding_field_name(arm)
-        "local_match_binding_#{@async_binding_counter}"
-      end
-
       def let_else_storage_c_name(statement, env)
         return fresh_c_temp_name(env, "let_else_discard") if let_else_discard_binding_syntax?(statement)
 
@@ -1133,100 +1005,6 @@ module MilkTea
         [storage_type, success_type, return_type, nil]
       end
 
-      def prepare_result_propagation_for_inline_lowering(expression, env:, allow_void_success: false)
-        storage_type, success_type, return_type, error_type = infer_result_propagation_types(expression, env:, allow_void_success:)
-        is_option = option_let_else_type?(storage_type)
-
-        env[:prepared_expression_cleanups] ||= []
-        cleanup_start = env[:prepared_expression_cleanups].length
-        operand_setup, operand = prepare_expression_for_inline_lowering(expression.operand, env:, expected_type: storage_type)
-        operand_cleanups = env[:prepared_expression_cleanups].drop(cleanup_start)
-
-        result_name = fresh_c_temp_name(env, "propagate")
-        result_ref = IR::Name.new(name: result_name, type: storage_type, pointer: false)
-        return_context = env.fetch(:return_context)
-        failure_return = if storage_type == return_type
-                           result_ref
-                         elsif is_option
-                           IR::VariantLiteral.new(
-                             type: return_type,
-                             arm_name: "none",
-                             fields: [],
-                           )
-                         else
-                           IR::VariantLiteral.new(
-                             type: return_type,
-                             arm_name: "failure",
-                             fields: [
-                               IR::AggregateField.new(
-                                 name: "error",
-                                 value: variant_binding_projection_expression(result_ref, storage_type, "failure", "error", error_type),
-                               ),
-                             ],
-                           )
-                         end
-        failure_cleanup = operand_cleanups.flat_map(&:itself)
-        failure_terminator = if return_context[:async_info]
-                               failure_cleanup +
-                                 lower_async_cleanup_entries(
-                                   return_context[:local_defers],
-                                   return_context[:active_defers],
-                                   frame_expr: return_context.fetch(:frame_expr),
-                                   raw_frame_expr: return_context.fetch(:raw_frame_expr),
-                                   async_info: return_context.fetch(:async_info),
-                                 ) +
-                                 async_complete_statements(
-                                   frame_expr: return_context.fetch(:frame_expr),
-                                   raw_frame_expr: return_context.fetch(:raw_frame_expr),
-                                   async_info: return_context.fetch(:async_info),
-                                   value: failure_return,
-                                 )
-                             else
-                               failure_cleanup +
-                                 cleanup_statements(return_context[:local_defers], return_context[:active_defers]) +
-                                 [IR::ReturnStmt.new(value: failure_return, source_path: @ctx.current_analysis_path)]
-                             end
-
-        if success_type == @ctx.types.fetch("void")
-          return [
-            operand_setup + [
-              IR::LocalDecl.new(
-                name: result_name,
-                linkage_name: result_name,
-                type: storage_type,
-                value: lower_contextual_expression(operand, env:, expected_type: storage_type),
-              ),
-              IR::IfStmt.new(
-                condition: let_else_failure_condition(result_ref, storage_type),
-                then_body: failure_terminator,
-                else_body: nil,
-              ),
-            ],
-            nil,
-          ]
-        end
-
-        projection = is_option ? :option_some_value : :result_success_value
-        register_prepared_temp!(env, result_name, success_type, storage_type:, projection:)
-
-        [
-          operand_setup + [
-            IR::LocalDecl.new(
-              name: result_name,
-              linkage_name: result_name,
-              type: storage_type,
-              value: lower_contextual_expression(operand, env:, expected_type: storage_type),
-            ),
-            IR::IfStmt.new(
-              condition: let_else_failure_condition(result_ref, storage_type),
-              then_body: failure_terminator,
-              else_body: nil,
-            ),
-          ],
-          AST::Identifier.new(name: result_name),
-        ]
-      end
-
       def c_type_name(type)
         if type.is_a?(Types::Nullable)
           return "nullable_#{c_type_name(type.base)}"

data/lib/milk_tea/core/module_loader.rb

@@ -334,55 +334,40 @@ module MilkTea
     private_class_method :raise_platform_conflict!
 
     def check_path(path)
-      resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
-      shared_cache_mtime = nil
-      shared_cache_mtime_checked = false
-
-      return @analysis_cache[resolved_path] if @analysis_cache.key?(resolved_path)
-
-      if use_shared_cache?
-        entry = @shared_cache[resolved_path]
-        if entry
-          shared_cache_mtime_checked = true
-          shared_cache_mtime = File.mtime(resolved_path).to_f rescue nil
-          if shared_cache_mtime && entry[:mtime] == shared_cache_mtime
-            @analysis_cache[resolved_path] = entry[:analysis]
-            return entry[:analysis]
-          end
-        end
-      end
+      resolved_path, ast, cached = check_module_cache(path)
+      return cached if cached
 
-      if @checking_paths.include?(resolved_path)
-        raise ModuleLoadError.new("cyclic import detected", path: resolved_path)
-      end
-
-      @checking_paths << resolved_path
-      ast = load_file(resolved_path)
       imported_modules = imported_modules_for_ast(ast, importer_path: resolved_path)
-
       global_index = build_global_import_index(ast)
       analysis = SemanticAnalyzer.check(ast, imported_modules:, path: resolved_path, global_import_index: global_index)
       @analysis_cache[resolved_path] = analysis
+      update_shared_cache(resolved_path, analysis)
+      analysis
+    ensure
+      @checking_paths.pop if @checking_paths.last == resolved_path
+    end
 
-      if use_shared_cache?
-        mtime = if shared_cache_mtime_checked
-                  shared_cache_mtime
-                else
-                  File.mtime(resolved_path).to_f rescue nil
-                end
-        @shared_cache[resolved_path] = { mtime: mtime, analysis: analysis } if mtime
-      end
+    def check_path_collecting_errors(path)
+      resolved_path, ast, cached = check_module_cache(path, extra_cache: @collecting_analysis_cache)
+      return cached if cached
+
+      imported_modules = imported_modules_for_ast_collecting_errors(ast, importer_path: resolved_path).modules
+      result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules:, path: resolved_path)
+      analysis = result[:analysis]
+      raise(result[:errors].first || ModuleLoadError.new("module analysis unavailable", path: resolved_path)) unless analysis
 
+      @collecting_path_errors[resolved_path] = result[:errors]
+      @collecting_analysis_cache[resolved_path] = analysis
       analysis
     ensure
       @checking_paths.pop if @checking_paths.last == resolved_path
     end
 
-    def check_path_collecting_errors(path)
+    def check_module_cache(path, extra_cache: nil)
       resolved_path = self.class.resolve_source_path(path, platform: @platform, error_class: ModuleLoadError)
 
-      return @analysis_cache[resolved_path] if @analysis_cache.key?(resolved_path)
-      return @collecting_analysis_cache[resolved_path] if @collecting_analysis_cache.key?(resolved_path)
+      return [resolved_path, nil, @analysis_cache[resolved_path]] if @analysis_cache.key?(resolved_path)
+      return [resolved_path, nil, extra_cache[resolved_path]] if extra_cache&.key?(resolved_path)
 
       if use_shared_cache?
         entry = @shared_cache[resolved_path]
@@ -390,27 +375,23 @@ module MilkTea
           mtime = File.mtime(resolved_path).to_f rescue nil
           if mtime && entry[:mtime] == mtime
             @analysis_cache[resolved_path] = entry[:analysis]
-            return entry[:analysis]
+            return [resolved_path, nil, entry[:analysis]]
           end
         end
       end
 
-      if @checking_paths.include?(resolved_path)
-        raise ModuleLoadError.new("cyclic import detected", path: resolved_path)
-      end
+      raise ModuleLoadError.new("cyclic import detected", path: resolved_path) if @checking_paths.include?(resolved_path)
 
       @checking_paths << resolved_path
       ast = load_file(resolved_path)
-      imported_modules = imported_modules_for_ast_collecting_errors(ast, importer_path: resolved_path).modules
-      result = SemanticAnalyzer.check_collecting_errors(ast, imported_modules:, path: resolved_path)
-      analysis = result[:analysis]
-      raise(result[:errors].first || ModuleLoadError.new("module analysis unavailable", path: resolved_path)) unless analysis
+      [resolved_path, ast, nil]
+    end
 
-      @collecting_path_errors[resolved_path] = result[:errors]
-      @collecting_analysis_cache[resolved_path] = analysis
-      analysis
-    ensure
-      @checking_paths.pop if @checking_paths.last == resolved_path
+    def update_shared_cache(resolved_path, analysis)
+      return unless use_shared_cache?
+
+      mtime = File.mtime(resolved_path).to_f rescue nil
+      @shared_cache[resolved_path] = { mtime:, analysis: } if mtime
     end
 
     def parse_file(path)

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

@@ -24,7 +24,7 @@ module MilkTea
         attributes = parse_attribute_applications
         visibility, visibility_token = parse_visibility
 
-        if legacy_layout_modifier_start?(peek)
+        if builtin_attribute_identifier?(peek)
           raise error(peek, "layout modifiers must use attributes like @[packed] or @[align(...)]")
         elsif match(:attribute)
           reject_attributes!(attributes, "attribute")
@@ -185,7 +185,7 @@ module MilkTea
         if match(:public)
           reject_attributes!(attributes)
           raise error(previous, "public is not allowed in external files")
-        elsif legacy_layout_modifier_start?(peek)
+        elsif builtin_attribute_identifier?(peek)
           raise error(peek, "layout modifiers must use attributes like @[packed] or @[align(...)]")
         elsif match(:attribute)
           reject_attributes!(attributes)

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

@@ -124,7 +124,7 @@ module MilkTea
       end
 
       def top_level_recovery_start?(token)
-        token.column.to_i <= 1 && (TOP_LEVEL_RECOVERY_START_TYPES.include?(token.type) || legacy_layout_modifier_start?(token))
+        token.column.to_i <= 1 && (TOP_LEVEL_RECOVERY_START_TYPES.include?(token.type) || builtin_attribute_identifier?(token))
       end
     end
   end

data/lib/milk_tea/core/parser.rb

@@ -290,7 +290,7 @@ module MilkTea
       @tokens[@current + 1]&.type == :identifier
     end
 
-    def legacy_layout_modifier_start?(token)
+    def builtin_attribute_identifier?(token)
       token&.type == :identifier && BUILTIN_ATTRIBUTE_NAME_LEXEMES.include?(token.lexeme)
     end
 

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

@@ -783,143 +783,26 @@ module MilkTea
       end
 
       def infer_integer_match_expression(expression, scrutinee_type, scopes:, expected_type:)
-        has_wildcard = expression.arms.any? { |arm| wildcard_pattern?(arm.pattern) }
-        raise_sema_error("match on integer type #{scrutinee_type} requires a wildcard arm (_:)") unless has_wildcard
-
-        covered_values = {}
-        wildcard_seen = false
         arm_entries = []
-
-        expression.arms.each do |arm|
-          if arm.pattern.is_a?(AST::ErrorExpr)
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          if wildcard_pattern?(arm.pattern)
-            raise_sema_error("duplicate wildcard arm in match") if wildcard_seen
-
-            wildcard_seen = true
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          if arm.pattern.is_a?(AST::RangeExpr)
-            start_val = arm.pattern.start_expr
-            end_val   = arm.pattern.end_expr
-            unless (start_val.is_a?(AST::IntegerLiteral) || start_val.is_a?(AST::CharLiteral)) &&
-                   (end_val.is_a?(AST::IntegerLiteral) || end_val.is_a?(AST::CharLiteral))
-              raise_sema_error("range match arm bounds must be integer or char literals, got #{start_val.class.name}..#{end_val.class.name}")
-            end
-
-            raise_sema_error("range match arm start #{start_val.value} must be <= end #{end_val.value}") if start_val.value > end_val.value
-
-            range_key = [start_val.value, end_val.value]
-            raise_sema_error("duplicate match arm range #{range_key[0]}..#{range_key[1]}") if covered_values.key?(range_key)
-
-            covered_values[range_key] = true
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          unless arm.pattern.is_a?(AST::IntegerLiteral) || arm.pattern.is_a?(AST::CharLiteral)
-            raise_sema_error("match arm for integer scrutinee must be an integer literal, char literal, range, or _, got #{arm.pattern.class.name}")
-          end
-
-          value = arm.pattern.value
-          raise_sema_error("duplicate match arm value #{value}") if covered_values.key?(value)
-
-          covered_values[value] = true
+        each_integer_match_arm(expression, scrutinee_type, scopes:) do |arm|
           arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
         end
-
         match_expression_common_type(arm_entries, expected_type)
       end
 
       def infer_string_match_expression(expression, scrutinee_type, scopes:, expected_type:)
-        has_wildcard = expression.arms.any? { |arm| wildcard_pattern?(arm.pattern) }
-        raise_sema_error("match on str requires a wildcard arm (_:)") unless has_wildcard
-
-        covered_values = {}
-        wildcard_seen = false
         arm_entries = []
-
-        expression.arms.each do |arm|
-          if arm.pattern.is_a?(AST::ErrorExpr)
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          if wildcard_pattern?(arm.pattern)
-            raise_sema_error("duplicate wildcard arm in match") if wildcard_seen
-            wildcard_seen = true
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          unless arm.pattern.is_a?(AST::StringLiteral)
-            raise_sema_error("match arm for str scrutinee must be a string literal or _, got #{arm.pattern.class.name}")
-          end
-
-          value = arm.pattern.value
-          raise_sema_error("duplicate match arm value \"#{value}\"") if covered_values.key?(value)
-
-          covered_values[value] = true
+        each_string_match_arm(expression, scrutinee_type, scopes:) do |arm|
           arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
         end
-
         match_expression_common_type(arm_entries, expected_type)
       end
 
       def infer_tuple_match_expression(expression, scrutinee_type, scopes:, expected_type:)
-        has_wildcard = expression.arms.any? { |arm| wildcard_pattern?(arm.pattern) }
-        raise_sema_error("match on tuple type #{scrutinee_type} requires a wildcard arm (_:)") unless has_wildcard
-
-        arity = scrutinee_type.element_types.length
-        covered_values = {}
-        wildcard_seen = false
         arm_entries = []
-
-        expression.arms.each do |arm|
-          if arm.pattern.is_a?(AST::ErrorExpr)
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          if wildcard_pattern?(arm.pattern)
-            raise_sema_error("duplicate wildcard arm in match") if wildcard_seen
-            wildcard_seen = true
-            arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
-            next
-          end
-
-          unless arm.pattern.is_a?(AST::ExpressionList)
-            raise_sema_error("match arm for tuple scrutinee must be a tuple literal or _, got #{arm.pattern.class.name}")
-          end
-
-          elements = arm.pattern.elements
-          raise_sema_error("tuple match arm has #{elements.length} elements but scrutinee has #{arity}") unless elements.length == arity
-
-          values = elements.map do |elem|
-            if elem.is_a?(AST::Identifier) && elem.name == "_"
-              :wildcard
-            elsif elem.is_a?(AST::IntegerLiteral) || elem.is_a?(AST::CharLiteral) ||
-                  elem.is_a?(AST::StringLiteral) || elem.is_a?(AST::BooleanLiteral)
-              elem.value
-            else
-              raise_sema_error("tuple match arm element must be a literal or _, got #{elem.class.name}")
-            end
-          end
-
-          all_literal = values.all? { |v| v != :wildcard }
-          if all_literal
-            raise_sema_error("duplicate tuple match arm #{arm.pattern.elements.map { |e| e.respond_to?(:value) ? e.value.inspect : '_' }.join(', ')}") if covered_values.key?(values)
-            covered_values[values] = true
-          end
-
+        each_tuple_match_arm(expression, scrutinee_type, scopes:) do |arm|
           arm_entries << [infer_match_expression_arm_value(arm, scopes:, expected_type:), arm.value]
         end
-
         match_expression_common_type(arm_entries, expected_type)
       end