Describe the bug
Compiling the small module below on OTP 28 (release branch & current master) crashes the SSA optimiser:

Sub pass ssa_opt_destructive_update
test.erl: internal error in pass beam_ssa_opt:
exception error: no function clause matching
beam_ssa_destructive_update:merge_patches(
        {tuple_element,2,{self,init_writable},0},
        {self,heap_tuple})
  in function  beam_ssa_destructive_update:merge_phi_patch/2 (beam_ssa_destructive_update.erl:988)
  ...

The same file compiles cleanly on OTP 27.x.

To Reproduce

1. Save the module below as test.erl.

2. In an Erlang shell running OTP 28:

   1> c("test.erl").

3. Observe the crash reported above.

% test.erl
-module(test).
-export([decode/1]).

-record(state, {a = undefined, b = <<>>, c = true}).

decode(Text) ->
    State = case lists:member(abc, []) of
                true  -> #state{c = false};
                false -> #state{}
            end,
    get_value(Text, State).

get_value(<<"\"", Bin/binary>>, S) ->
    string_encode_dec(Bin, S#state{a = undefined}).

string_encode_dec(Bin, S=#state{b = Buf}) ->
    string1(Bin, size(Buf), S).

string1(<<"\"", Rem/binary>>, SizeOfB, S=#state{b = Buf}) ->
    Prefix = <<>>,
    case SizeOfB == size(Buf) of
        false ->
            Buf2 = <<Buf/binary, Prefix/binary>>,
            get_value(Rem, S#state{b = <<>>})
    end.

Expected behavior
The module should compile without crashing, as it does on OTP 27.

Affected 6D14 versions

• OTP 28.0
• Current master
• Not reproducible on OTP 27.3 or earlier 27.x releases.

Additional context

• Root cause: In beam_ssa_destructive_update:patch_is/5, OTP 28 now uses lists:splitwith/2, which may deliver a patch list ordered as:

  [{tuple_element,…}, {self,heap_tuple}]

  instead of {self,heap_tuple} first (OTP 27 order).
  merge_phi_patch/2 subsequently calls merge_patches/2 with that list’s head/tail; the existing merge_patches/2 is asymmetric and only matches the heap-tuple-first form, resulting in the function-clause crash.

• Minimal fix (works for me):

  %% beam_ssa_destructive_update.erl
  
  merge_patches({tuple_element,Idx,Element,Depth}, {self,heap_tuple}) ->
      {tuple_element,Idx,Element,Depth};
  merge_patches({tuple_elements,Elements}, {self,heap_tuple}) ->
      {tuple_elements,Elements};

  Making merge_patches/2 commutative (or normalising patch order before merging) also resolves the issue.

• No runtime impact observed once compilation succeeds.

Thanks!
Trevor