Bug 2451 – Adding structs that use opAssign or postblit to an AA is broken

import std.variant; void main() { Variant[string] a; Variant v = 1; a["wut?"] = v; } ---- core.exception.ArrayBoundsException@Test(23): Array index out of bounds Key type is irrelevant.

(In reply to comment #0) > import std.variant; > > void main() > { > Variant[string] a; > Variant v = 1; > a["wut?"] = v; > } > ---- > core.exception.ArrayBoundsException@Test(23): Array index out of bounds > > Key type is irrelevant. > I reduced this further: struct Wyda { void opAssign(Wyda) {assert(&this !is null);} } void main() { Wyda[int] a; a[4] = Wyda(); } The assert will fail! Hash tables for value types that define opAssign seem to have a problem.

Adding structs that use opAssign or postblit to an AA is broken. The following also produces a range violation: struct Foo { this(this){} } void main() { Foo[string] stuff; stuff["foo"] = Foo.init; }

Perfect timing, thanks. I just ran into that but had no time to investigate. The type Tuple!(uint, "count", float, "distance")[uint] does not work, but the type S[uint] (where struct S { uint count; float distance; }) does work.

import std.variant; Variant[char[]][int] aa; aa[0]["a"] = "bla0"; aa[0]["b"] = 100; aa[1]["a"] = "bla1"; aa[1]["b"] = 200; With 32-bit Linux and dmd2.039 or dmd2.040 Compile : success Running : core.exception.RangeError@test(30): Range violation

I don't have a patch for this, but the direct reason for the observed behaviour is in expression.c, line 9023. If the type being inserted has an opAssign overload, then it drops out of AssignExp::semantic() immediately and discards the rest of the expression. This isn't a real patch, since it still doesn't call postblit. /* If it is an assignment from a 'foreign' type, * check for operator overloading. */ if (t1->ty == Tstruct) { StructDeclaration *sd = ((TypeStruct *)t1)->sym; if (op == TOKassign) { Expression *e = op_overload(sc); + if (e1->op==TOKindex && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + // If it is an AA, the assignment + // should be treated as a function call (Bugzilla 2451) + } + else if (e) return e; }

*** Issue 2938 has been marked as a duplicate of this issue. ***

*** Issue 4121 has been marked as a duplicate of this issue. ***

Bug 3705 (Can't add structs with alias this to an AA) is probably related.

Here's a patch. Do the opAssign onto a temporary variable, then blit the temporary into the AA as normal. TEST CASE: struct Foo { int z = 3; void opAssign(Foo x) { z= 2;} } struct Foo2 { int z = 3; this(this){ z = 17; } } void main() { Foo[string] stuff; stuff["foo"] = Foo.init; assert(stuff["foo"].z == 2); Foo2[string] stuff2; Foo2 q; stuff2["dog"] = q; assert(stuff2["dog"].z == 17); } PATCH: expression.c line 8966, AssignExp::semantic. --------------------- /* If it is an assignment from a 'foreign' type, * check for operator overloading. */ if (t1->ty == Tstruct) { StructDeclaration *sd = ((TypeStruct *)t1)->sym; if (op == TOKassign) { Expression *e = op_overload(sc); + if (e && e1->op==TOKindex && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + // Deal with AAs (Bugzilla 2451) + // Rewrite as: + // e1 = (typeof(e2) tmp = void, tmp = e2, tmp); + Identifier *id = Lexer::uniqueId("__aatmp"); + VarDeclaration *v = new VarDeclaration(loc, e2->type, + id, new VoidInitializer(NULL)); + v->storage_class |= STCctfe; + Expression *de = new DeclarationExp(loc, v); + VarExp *ve = new VarExp(loc, v); + AssignExp *ae = new AssignExp(loc, ve, e2); + e = ae->op_overload(sc); + e2 = new CommaExp(loc, new CommaExp(loc, de, e), ve); + e2 = e2->semantic(sc); + } + else if (e) return e;

*** Issue 1886 has been marked as a duplicate of this issue. ***