Fix Issue 21288 & 10886 - incorrect this pointer

compiler/src/dmd/expressionsem.d

@@ -1155,6 +1155,69 @@ L1:
     return e1;
 }
 
+/*
+ * Check whether `outerFunc` and `calledFunc` have the same `this`.
+ * If `calledFunc` is the member of a base class of the class that contains
+ * `outerFunc` we consider that they have the same this.
+ *
+ * This function is used to test whether `this` needs to be prepended to
+ * a function call or function symbol. For example:
+ *
+ * struct X
+ * {
+ *    void gun() {}
+ * }
+ * struct A
+ * {
+ *      void fun() {}
+ *      void sun()
+ *      {
+ *          fun();
+ *          X.gun();  // error
+ *      }
+ * }
+ *
+ * When `fun` is called, `outerfunc` = `sun` and `calledFunc = `fun`.
+ * `sun` is a member of `A` and `fun` is also a member of `A`, therefore
+ * `this` can be prepended to `fun`. When `gun` is called (it will result
+ * in an error, but that is not relevant here), which is a member of `X`,
+ * no `this` is needed because the outer function does not have the same
+ * `this` as `gun`.
+ *
+ * Returns:
+ *  `true` if outerFunc and calledFunc may use the same `this` pointer.
+ * `false` otherwise.
+ */
+private bool haveSameThis(FuncDeclaration outerFunc, FuncDeclaration calledFunc)
+{
+    auto thisAd = outerFunc.isMemberLocal();
+    if (!thisAd)
+        return false;
+
+    auto requiredAd = calledFunc.isMemberLocal();
+    if (!requiredAd)
+        return false;
+
+    if (thisAd == requiredAd)
+        return true;
+
+    // outerfunc is the member of a base class that contains calledFunc,
+    // then we consider that they have the same this.
+    auto cd = requiredAd.isClassDeclaration();
+    if (!cd)
+        return false;
+
+    if (cd.isBaseOf2(thisAd.isClassDeclaration()))
+        return true;
+
+    // if outerfunc is the member of a nested aggregate, then let
+    // getRightThis take care of this.
+    if (thisAd.isNested())
+        return true;
+
+    return false;
+}
+
 /***************************************
  * Pull out any properties.
  */
@@ -5209,7 +5272,8 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                 if (exp.f.checkNestedReference(sc, exp.loc))
                     return setError();
 
-                if (hasThis(sc))
+                auto memberFunc = hasThis(sc);
+                if (memberFunc && haveSameThis(memberFunc, exp.f))
                 {
                     // Supply an implicit 'this', as in
                     //    this.ident
@@ -6892,8 +6956,6 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
         AggregateDeclaration ad = f.isMemberLocal();
         if (f.needThis())
             e.e1 = getRightThis(e.loc, sc, ad, e.e1, f);
-        if (e.e1.op == EXP.error)
-            return setError();
 
         if (f.type.ty == Tfunction)
         {
@@ -7207,7 +7269,8 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
                 }
                 if (f.needThis())
                 {
-                    if (hasThis(sc))
+                    auto memberFunc = hasThis(sc);
+                    if (memberFunc && haveSameThis(memberFunc, f))
                     {
                         /* Should probably supply 'this' after overload resolution,
                          * not before.

compiler/test/compilable/test19295.d

@@ -0,0 +1,10 @@
+struct S1(T...) {
+    auto fun() {
+        static assert(__traits(compiles, &T[0]));
+    }
+}
+
+struct S2 {
+    void gun() {}
+    S1!gun overloaded;
+}

compiler/test/compilable/testcorrectthis.d

@@ -0,0 +1,37 @@
+// https://issues.dlang.org/show_bug.cgi?id=10886
+
+struct A
+{
+    @property int foo() { return 0; }
+    int bar() { return 0; }
+}
+
+struct B
+{
+    void bar()
+    {
+        alias f = typeof(A.foo);  // NG
+        alias b = typeof(A.bar);  // ok
+    }
+}
+
+// https://issues.dlang.org/show_bug.cgi?id=21288
+
+struct XA
+{
+    int p;
+}
+
+struct XB
+{
+    XA a() { return XA.init; }
+    alias a this;
+}
+
+struct XC
+{
+    void foo()
+    {
+        static assert(XB.p.stringof == "p"); // Error: this for s needs to be type B not type C
+    }
+}

compiler/test/fail_compilation/fail61.d

@@ -4,7 +4,7 @@ TEST_OUTPUT:
 fail_compilation/fail61.d(22): Error: no property `B` for type `fail61.A.B`
 fail_compilation/fail61.d(23): Error: no property `B` for type `fail61.A.B`
 fail_compilation/fail61.d(32): Error: no property `A2` for type `fail61.B2`
-fail_compilation/fail61.d(41): Error: `this` for `foo` needs to be type `B3` not type `fail61.C3`
+fail_compilation/fail61.d(41): Error: need `this` for `foo` of type `void()`
 ---
 */
 

compiler/test/fail_compilation/ice9439.d

@@ -1,8 +1,8 @@
 /*
 TEST_OUTPUT:
 ---
-fail_compilation/ice9439.d(12): Error: `this` for `foo` needs to be type `Derived` not type `ice9439.Base`
-fail_compilation/ice9439.d(12):        while evaluating: `static assert((__error).foo())`
+fail_compilation/ice9439.d(12): Error: need `this` for `foo` of type `int()`
+fail_compilation/ice9439.d(12):        while evaluating: `static assert(foo())`
 fail_compilation/ice9439.d(19): Error: template instance `ice9439.Base.boo!(foo)` error instantiating
 ---
 */