Crash in coder/executor with foo!{[1,2,3]} syntax

[fingolfin]

Consider this:

gap> f := function(l) l!{[1,3]} := [42, 23]; end;;
gap> Display(f);
Error, Panic: cannot print statement of type '55' in
  <corrupted statement>  called from
...
gap> f([]);
Panic: tried to execute a statement of unknown type '55'

With some more effort, it can even lead to a crash:

gap> function()
>   local l;
>   l:=[1,2,3];
>   Display(l);
>   l![1] := 42;
>   Display(l![1]);
>   Display(IsBound(l![1]));
>   Unbind(l![1]);
>   Display(l);
>   l!{[1,3]} := [42, 23];
>   Display(l);
>   Display(l!{[3,1]});
> end();
[ 1, 2, 3 ]
42
true
[ , 2, 3 ]
Panic: tried to execute a statement of unknown type '55'
[ , 2, 3 ]
Panic: tried to evaluate an expression of unknown type '189'
Segmentation fault: 11

What's going on here? Well, that's because support for list slices via the list{indices} syntax was not fully extended to its "bang-variant", list!{indices}, which is for accessing slices of positional objects.

In the interpreter, we thus just print an error: "sorry, not supported". But when coding, the coder happily codes this. But printing and executing was never implemented for these kinds of statements, hence the weird errors and ultimately the crash. Specifically, at least these six statement/expression types are affected:

T_ASSS_POSOBJ
T_ASS_POSOBJ_LEV
T_ASSS_POSOBJ_LEV
T_ELMS_POSOBJ
T_ELM_POSOBJ_LEV
T_ELMS_POSOBJ_LEV

Now, we could implement printing and coding for them, in a minimalistic fashion. But I wonder if it is worth it -- do we really want to support !{...}? As far as I can tell, it's not documented. So I would rather prefer to remove it completely -- most of the existing support code ends up printing "sorry, not yet implemented" anyway.

Or perhaps somebody can think of a reason to keep it?