test-solution

Author: abulgit

compiler/src/dmd/astbase.d

@@ -3867,6 +3867,7 @@ struct ASTBase
         // .next is the return type
 
         ParameterList parameterList;   // function parameters
+        Loc paramCloseLoc;             // location of closing ')' of parameter list, for diagnostics
 
         private enum FunctionFlag : uint
         {
@@ -3945,6 +3946,7 @@ struct ASTBase
             t.isInOutQual = isInOutQual;
             t.trust = trust;
             t.fargs = fargs;
+            t.paramCloseLoc = paramCloseLoc;
             return t;
         }
 

compiler/src/dmd/funcsem.d

@@ -2116,10 +2116,11 @@ FuncDeclaration resolveFuncCall(Loc loc, Scope* sc, Dsymbol s,
             .error(loc, "%smethod `%s` is not callable using a %sobject",
                    funcBuf.peekChars(), fd.toPrettyChars(), thisBuf.peekChars());
 
+        const qualLoc = tf.paramCloseLoc != Loc.initial ? tf.paramCloseLoc : fd.loc;
         if (mismatches.isNotShared)
-            .errorSupplemental(fd.loc, "Consider adding `shared` here");
+            .errorSupplemental(qualLoc, "Consider adding `shared` here");
         else if (mismatches.isMutable)
-            .errorSupplemental(fd.loc, "Consider adding `const` or `inout` here");
+            .errorSupplemental(qualLoc, "Consider adding `const` or `inout` here");
         return null;
     }
 

compiler/src/dmd/mtype.d

@@ -1343,6 +1343,7 @@ extern (C++) final class TypeFunction : TypeNext
     import dmd.common.bitfields : generateBitFields;
     mixin(generateBitFields!(BitFields, ushort));
 
+    Loc paramCloseLoc;          // location of closing ')' of parameter list, for diagnostics
     LINK linkage;               // calling convention
     TRUST trust;                // level of trust
     PURE purity = PURE.impure;
@@ -1425,6 +1426,7 @@ extern (C++) final class TypeFunction : TypeNext
         t.trust = trust;
         t.inferenceArguments = inferenceArguments;
         t.isCtor = isCtor;
+        t.paramCloseLoc = paramCloseLoc;
         return t;
     }
 

compiler/src/dmd/mtype.h

@@ -462,6 +462,7 @@ class TypeFunction final : public TypeNext
     // .next is the return type
 
     ParameterList parameterList; // function parameters
+    Loc paramCloseLoc;           // location of closing ')' of parameter list, for diagnostics
     uint16_t bitFields;
     LINK linkage;                // calling convention
     TRUST trust;                 // level of trust

compiler/src/dmd/parse.d

@@ -4262,14 +4262,16 @@ class Parser(AST, Lexer = dmd.lexer.Lexer) : Lexer
                     }
 
                     auto parameterList = parseParameterList(null);
+                    const paramCloseLoc = prevloc; // location of closing ')'
 
                     /* Parse const/immutable/shared/inout/nothrow/pure/return postfix
                      */
                     // merge prefix storage classes
                     STC stc = parsePostfix(storageClass, pudas);
 
-                    AST.Type tf = new AST.TypeFunction(parameterList, t, linkage, stc);
-                    tf = AST.addSTC(tf, stc);
+                    auto tfunc = new AST.TypeFunction(parameterList, t, linkage, stc);
+                    tfunc.paramCloseLoc = paramCloseLoc;
+                    AST.Type tf = AST.addSTC(tfunc, stc);
                     if (pdisable)
                         *pdisable = stc & STC.disable ? true : false;
 

compiler/src/dmd/statementsem.d

@@ -828,7 +828,9 @@ Statement statementSemanticVisit(Statement s, Scope* sc)
                                     !fd.type.mod ? "mutable" : fd.type.modToChars(),
                                     fd.toPrettyChars(),
                                     fs.aggr.type.toChars());
-                                errorSupplemental(fd.loc, "Consider adding a method type qualifier here");
+                                const fdtf = fd.type.isTypeFunction();
+                                const qualLoc = fdtf && fdtf.paramCloseLoc != Loc.initial ? fdtf.paramCloseLoc : fd.loc;
+                                errorSupplemental(qualLoc, "Consider adding a method type qualifier here");
                                 return setError();
                             }
                         }

compiler/test/fail_compilation/issue22125.d

@@ -0,0 +1,42 @@
+// https://issues.dlang.org/show_bug.cgi?id=22125
+
+/*
+REQUIRED_ARGS: -verrors=context
+TEST_OUTPUT:
+---
+fail_compilation/issue22125.d(37): Error: mutable method `issue22125.S.doStuff` is not callable using a `const` object
+    s.doStuff();
+             ^
+fail_compilation/issue22125.d(30):        Consider adding `const` or `inout` here
+    void doStuff() { }
+                 ^
+fail_compilation/issue22125.d(38): Error: mutable method `issue22125.S.doStuffWithArgs` is not callable using a `const` object
+    s.doStuffWithArgs(1);
+                     ^
+fail_compilation/issue22125.d(31):        Consider adding `const` or `inout` here
+    void doStuffWithArgs(int a) { }
+                              ^
+fail_compilation/issue22125.d(40): Error: non-shared method `issue22125.S.doStuff` is not callable using a `shared` object
+    ss.doStuff();
+              ^
+fail_compilation/issue22125.d(30):        Consider adding `shared` here
+    void doStuff() { }
+                 ^
+---
+*/
+
+struct S
+{
+    void doStuff() { }
+    void doStuffWithArgs(int a) { }
+}
+
+void test()
+{
+    const S s;
+    s.doStuff();
+    s.doStuffWithArgs(1);
+    shared S ss;
+    ss.doStuff();
+}
+

compiler/test/fail_compilation/test24353.d

@@ -9,13 +9,13 @@ fail_compilation/test24353.d(37): Error: mutable method `test24353.S.opApply` is
                 ^
 fail_compilation/test24353.d(28):        Consider adding a method type qualifier here
     int opApply(int delegate(int) dg)
-        ^
+                                    ^
 fail_compilation/test24353.d(40): Error:  shared const method `test24353.S2.opApply` is not callable using a `const(S2)` foreach aggregate
     foreach (i, e; s2) {} // mod error
                    ^
 fail_compilation/test24353.d(47):        Consider adding a method type qualifier here
     int opApply(int delegate(int, int) dg) const shared;
-        ^
+                                         ^
 fail_compilation/test24353.d(42): Error: cannot uniquely infer `foreach` argument types
     foreach (i, e; const S3()) {} // cannot infer
     ^