Primary Type Syntax

VERSION

@@ -1 +1 @@
-v2.112.0-beta.1
+v2.112.0-beta.1+PrimaryTypeSyntax

compiler/src/dmd/dsymbolsem.d

@@ -1072,7 +1072,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
 
         if ((dsym.storage_class & (STC.ref_ | STC.field)) == (STC.ref_ | STC.field) && dsym.ident != Id.This)
         {
-            .error(dsym.loc, "%s `%s` - field declarations cannot be `ref`", dsym.kind, dsym.toPrettyChars);
+            .error(dsym.loc, "%s `%s` - field declarations cannot be `ref`; use parentheses for a function pointer or delegate type with `ref` return", dsym.kind, dsym.toPrettyChars);
         }
 
         if (dsym.type.hasWild())

compiler/src/dmd/hdrgen.d

@@ -4016,21 +4016,56 @@ private void visitFuncIdentWithPostfix(TypeFunction t, const char[] ident, ref O
         return;
     }
     t.inuse++;
+    bool parenWritten = false;
+    void openParenthesis()
+    {
+        if (!parenWritten)
+        {
+            buf.put('(');
+            parenWritten = true;
+        }
+    }
     if (t.linkage > LINK.d && hgs.ddoc != 1 && !hgs.hdrgen)
     {
+        openParenthesis();
         linkageToBuffer(buf, t.linkage);
         buf.put(' ');
     }
     if (t.linkage == LINK.objc && isStatic)
-        buf.write("static ");
+        buf.put("static ");
     if (t.next)
     {
+        if (t.isRef)
+        {
+            openParenthesis();
+            buf.put("ref ");
+        }
+        immutable bool hasNestedNonParendCallable = {
+            for ({ Type tt = t; TypeNext tn = null; } (tn = tt.isTypeNext) !is null;)
+            {
+                tt = tn.next;
+                switch (tt.ty)
+                {
+                    case Tsarray, Tarray, Taarray, Tpointer, Treference, Tdelegate, Tslice: continue;
+                    case Tfunction:
+                        TypeFunction tf = cast(TypeFunction) tt;
+                        return !tf.isRef && tf.linkage <= LINK.d;
+                    default: return false;
+                }
+            }
+            return false;
+        }();
+        if (hasNestedNonParendCallable) buf.writeByte('(');
         typeToBuffer(t.next, null, buf, hgs);
+        if (hasNestedNonParendCallable) buf.writeByte(')');
         if (ident)
             buf.put(' ');
     }
     else if (hgs.ddoc)
+    {
+        openParenthesis();
         buf.put("auto ");
+    }
     if (ident)
         buf.put(ident);
     parametersToBuffer(t.parameterList, buf, hgs);
@@ -4042,13 +4077,15 @@ private void visitFuncIdentWithPostfix(TypeFunction t, const char[] ident, ref O
         MODtoBuffer(buf, t.mod);
     }
 
-    void dg(string str)
+    void writeAttribute(string str)
     {
+        if (str == "ref") return; // 'ref' is handled above
         buf.put(' ');
         buf.put(str);
     }
-    t.attributesApply(&dg);
-
+    t.attributesApply(&writeAttribute);
+    if (parenWritten)
+        buf.put(')');
     t.inuse--;
 }
 

compiler/src/dmd/lexer.d

@@ -312,6 +312,15 @@ class Lexer
         return peek(t).value;
     }
 
+    /***********************
+     * Look 3 tokens ahead at value.
+     */
+    final TOK peekNext3()
+    {
+        Token* t = peek(peek(&token));
+        return peek(t).value;
+    }
+
     /****************************
      * Turn next token in buffer into a token.
      * Params:

compiler/src/dmd/mtype.d

@@ -1521,6 +1521,28 @@ extern (C++) abstract class Type : ASTNode
         inout(TypeNoreturn)   isTypeNoreturn()   { return ty == Tnoreturn  ? cast(typeof(return))this : null; }
         inout(TypeTag)        isTypeTag()        { return ty == Ttag       ? cast(typeof(return))this : null; }
 
+        inout(TypeArray)      isTypeArray()
+        {
+            switch (ty)
+            {
+            case Tsarray, Tarray, Taarray:
+                return cast(typeof(return))this;
+            default:
+                return null;
+            }
+        }
+        inout(TypeNext)       isTypeNext()
+        {
+            switch (ty)
+            {
+            case Tsarray, Tarray, Taarray:
+            case Tpointer, Treference, Tfunction, Tdelegate, Tslice:
+                    return cast(typeof(return))this;
+            default:
+                return null;
+            }
+        }
+
         extern (D) bool isStaticOrDynamicArray() const { return ty == Tarray || ty == Tsarray; }
     }
 
@@ -1594,6 +1616,8 @@ extern (C++) abstract class TypeNext : Type
         this.next = next;
     }
 
+    abstract override TypeNext syntaxCopy();
+
     override final int hasWild() const
     {
         if (ty == Tfunction)
@@ -2152,6 +2176,8 @@ extern (C++) abstract class TypeArray : TypeNext
         super(ty, next);
     }
 
+    abstract override TypeArray syntaxCopy();
+
     override void accept(Visitor v)
     {
         v.visit(this);