mt-lang 0.3.4 → 0.3.5

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

@@ -1672,5 +1672,99 @@ module MilkTea
         end
         expr
       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
   end
 end

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

@@ -1083,5 +1083,54 @@ module MilkTea
         end
       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
   end
 end