Make new AA allocate the associative array Impl

changelog/new-aa.dd

@@ -0,0 +1,16 @@
+`new` can now allocate an associative array
+
+This allows two associative array references to point to the same
+associative array instance before any keys have been inserted.
+
+---
+int[string] a = new int[string];
+auto b = a;
+...
+a["seven"] = 7;
+assert(b["seven"] == 7);
+---
+
+Note: Calling `new` is not needed before inserting keys on a null
+associative array reference - the instance will be allocated if it
+doesn't exist.

compiler/src/dmd/e2ir.d

@@ -1301,6 +1301,16 @@ elem* toElem(Expression e, IRState *irs)
             }
             e = el_combine(ezprefix, e);
         }
+        else if (auto taa = t.isTypeAArray())
+        {
+            Symbol *s = aaGetSymbol(taa, "New", 0);
+            elem *ti = getTypeInfo(ne, t, irs);
+            // aaNew(ti)
+            elem *ep = el_params(ti, null);
+            e = el_bin(OPcall, TYnptr, el_var(s), ep);
+            elem_setLoc(e, ne.loc);
+            return e;
+        }
         else
         {
             ne.error("internal compiler error: cannot new type `%s`\n", t.toChars());

compiler/src/dmd/expressionsem.d

@@ -3463,8 +3463,17 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
         if (!exp.arguments && exp.newtype.isTypeSArray())
         {
             auto ts = exp.newtype.isTypeSArray();
-            edim = ts.dim;
-            exp.newtype = ts.next;
+            // check `new Value[Key]`
+            ts.dim = ts.dim.expressionSemantic(sc);
+            if (ts.dim.op == EXP.type)
+            {
+                exp.newtype = new TypeAArray(ts.next, ts.dim.isTypeExp().type);
+            }
+            else
+            {
+                edim = ts.dim;
+                exp.newtype = ts.next;
+            }
         }
 
         ClassDeclaration cdthis = null;
@@ -3518,18 +3527,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
         {
             return setError();
         }
-        //https://issues.dlang.org/show_bug.cgi?id=20547
-        //exp.arguments are the "parameters" to [], not to a real function
-        //so the errors that come from preFunctionParameters are misleading
-        if (originalNewtype.ty == Tsarray)
-        {
-            if (preFunctionParameters(sc, exp.arguments, false))
-            {
-                exp.error("cannot create a `%s` with `new`", originalNewtype.toChars());
-                return setError();
-            }
-        }
-        else if (preFunctionParameters(sc, exp.arguments))
+        if (preFunctionParameters(sc, exp.arguments))
         {
             return setError();
         }
@@ -3885,6 +3883,15 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
 
             exp.type = exp.type.pointerTo();
         }
+        else if (tb.ty == Taarray)
+        {
+            // e.g. `new Alias(args)`
+            if (nargs)
+            {
+                exp.error("`new` cannot take arguments for an associative array");
+                return setError();
+            }
+        }
         else
         {
             exp.error("cannot create a `%s` with `new`", exp.type.toChars());

compiler/src/dmd/parse.d

@@ -9312,13 +9312,10 @@ LagainStc:
         {
             AST.TypeAArray taa = cast(AST.TypeAArray)t;
             AST.Type index = taa.index;
+            // `new Type[expr]` is a static array
             auto edim = AST.typeToExpression(index);
-            if (!edim)
-            {
-                error("cannot create a `%s` with `new`", t.toChars);
-                return new AST.NullExp(loc);
-            }
-            t = new AST.TypeSArray(taa.next, edim);
+            if (edim)
+                t = new AST.TypeSArray(taa.next, edim);
         }
         else if (token.value == TOK.leftParenthesis && t.ty != Tsarray)
         {

compiler/test/fail_compilation/misc_parser_err_cov1.d

@@ -10,7 +10,6 @@ fail_compilation/misc_parser_err_cov1.d(31): Error: expression expected, not `)`
 fail_compilation/misc_parser_err_cov1.d(32): Error: `type identifier : specialization` expected following `is`
 fail_compilation/misc_parser_err_cov1.d(33): Error: semicolon expected following auto declaration, not `auto`
 fail_compilation/misc_parser_err_cov1.d(33): Error: found `+` when expecting `(` following `mixin`
-fail_compilation/misc_parser_err_cov1.d(34): Error: cannot create a `char[float]` with `new`
 fail_compilation/misc_parser_err_cov1.d(35): Error: `key:value` expected for associative array literal
 fail_compilation/misc_parser_err_cov1.d(36): Error: basic type expected, not `;`
 fail_compilation/misc_parser_err_cov1.d(36): Error: `{ members }` expected for anonymous class
@@ -44,7 +43,7 @@ void main()
     auto tt = __traits(<o<);
     auto b = is ;
     auto mx1 = mixin +);
-    auto aa1 = new char[float];
+
     aa +=  [key:value, key];
     auto anon1 = new class;
     auto anon2 = new class {};

compiler/test/fail_compilation/newaa.d

@@ -0,0 +1,19 @@
+/*
+TEST_OUTPUT:
+---
+fail_compilation/newaa.d(14): Error: cannot implicitly convert expression `new string[string]` of type `string[string]` to `int[string]`
+fail_compilation/newaa.d(15): Error: function expected before `()`, not `new int[int]` of type `int[int]`
+fail_compilation/newaa.d(17): Error: `new` cannot take arguments for an associative array
+---
+*/
+#line 9
+void main()
+{
+    //https://issues.dlang.org/show_bug.cgi?id=11790
+    string[string] crash = new string[string];
+    //https://issues.dlang.org/show_bug.cgi?id=20547
+    int[string] c = new typeof(crash);
+    auto d = new int[int](5);
+    alias AA = char[string];
+    auto e = new AA(5);
+}

test/runnable/newaa.d

@@ -0,0 +1,23 @@
+void main()
+{
+    alias AA = int[string];
+    // aa is not ref
+    static void test(AA aa)
+    {
+        aa[""] = 0;
+    }
+    auto aa = new AA();
+    auto ab = new int[string];
+    auto ac = new typeof(aa);
+    test(aa);
+    test(ab);
+    test(ac);
+    assert(aa.length);
+    assert(ab.length);
+    assert(ac.length);
+
+    int[string] a = new int[string];
+    auto b = a;
+    a["seven"] = 7;
+    assert(b["seven"] == 7);
+}