Operator assignment and strict_types

From the Pike developers mailinglist:

22509896 2018-03-26 17:36 -0700 /41 lines/ Marc Simpson <marc@0branch.com>
Sender: SRS0+w18L=GR=lists.lysator.liu.se=pike-devel-bounces@lysator.liu.se
Imported: 2018-03-27 02:36 av Brevbäraren
External recipient: pike-devel@lists.lysator.liu.se
To: Pike (-) developers forum <20565>
Subject: Operator assignment and strict_types

Hi folks,

It looks like operator assignment (op=), increment and decrement statements aren't subjected to the same typechecks as their more explicit equivalents.

For example, neither the post-increment nor += statements below warn with strict_types enabled, even though they assign values outside of foo's restricted int domain:

int(3..3) foo = 3;
foo++; // no warning
foo += 1; // no warning
foo = foo + 1; // warning from strict_types

Similarly, operator assignment on aggregates fails to elicit a warning:

array(int) a = ({});
multiset(int) b = (<>);
mapping(int:int) c = ([]);

// no warnings
a += ({ "hey" });
b += (< "hey" >);
c += ([ "hey": "there" ]);

// warnings from strict_types
a = a + ({ "hey" });
b = b + (< "hey" >);
c = c + ([ "hey": "there" ]);

I'm guessing this is because the checks provided by the F_ASSIGN/F_ASSIGN_SELF case (las.c) only apply to direct assignment; op= and friends are presumably not instrumented for strict_types in the same manner.

Have there been any discussions around addressing this inconsistency?

Thanks,

Marc