Add missing test case for assertion functions with PropertySignature declarations (#59714)

Author: Andarist

tests/baselines/reference/assertionTypePredicates1.errors.txt

@@ -13,9 +13,10 @@ assertionTypePredicates1.ts(165,15): error TS1228: A type predicate is only allo
 assertionTypePredicates1.ts(170,5): error TS2775: Assertions require every name in the call target to be declared with an explicit type annotation.
 assertionTypePredicates1.ts(172,5): error TS2776: Assertions require the call target to be an identifier or qualified name.
 assertionTypePredicates1.ts(174,5): error TS2775: Assertions require every name in the call target to be declared with an explicit type annotation.
+assertionTypePredicates1.ts(200,5): error TS2775: Assertions require every name in the call target to be declared with an explicit type annotation.
 
 
-==== assertionTypePredicates1.ts (15 errors) ====
+==== assertionTypePredicates1.ts (16 errors) ====
     declare function isString(value: unknown): value is string;
     declare function isArrayOfStrings(value: unknown): value is string[];
 
@@ -243,4 +244,69 @@ assertionTypePredicates1.ts(174,5): error TS2775: Assertions require every name
             thing.good;
         }
     }
+    
+    class TestPropertyDeclaration1 {
+      assert = (value: unknown): asserts value => {};
+      other(x: unknown) {
+        this.assert(x); // error
+        ~~~~~~~~~~~
+!!! error TS2775: Assertions require every name in the call target to be declared with an explicit type annotation.
+!!! related TS2782 assertionTypePredicates1.ts:198:3: 'assert' needs an explicit type annotation.
+        x;
+      }
+    }
+    
+    class TestPropertyDeclaration2 {
+      assert: (v: unknown) => asserts v = (value) => {};
+      other(x: unknown) {
+        this.assert(x); // ok
+        x;
+      }
+    }
+    
+    declare class ParentInheritedPropertyDeclaration {
+      assert: (value: unknown) => asserts value;
+    }
+    class ChildInheritedPropertyDeclaration extends ParentInheritedPropertyDeclaration {
+      other(x: unknown) {
+        this.assert(x); // ok
+        x;
+      }
+    }
+    
+    interface TestPropertySignature {
+      assert: (value: unknown) => asserts value;
+    }
+    function testPropertySignature(
+      x: TestPropertySignature,
+      y: unknown,
+    ) {
+      x.assert(y); // ok
+      x;
+    }
+    function testFunctionThisParameter1(
+      this: TestPropertySignature,
+      x: unknown,
+    ) {
+      this.assert(x); // ok
+      x;
+    }
+    
+    interface TestMethodSignature {
+      assert(value: unknown): asserts value;
+    }
+    function testMethodSignature(
+      x: TestMethodSignature,
+      y: unknown,
+    ) {
+      x.assert(y); // ok
+      x;
+    }
+    function testFunctionThisParameter2(
+      this: TestMethodSignature,
+      x: unknown,
+    ) {
+      this.assert(x); // ok
+      x;
+    }
 

tests/baselines/reference/assertionTypePredicates1.js

@@ -196,6 +196,68 @@ function example1(things: Thing[]) {
         thing.good;
     }
 }
+
+class TestPropertyDeclaration1 {
+  assert = (value: unknown): asserts value => {};
+  other(x: unknown) {
+    this.assert(x); // error
+    x;
+  }
+}
+
+class TestPropertyDeclaration2 {
+  assert: (v: unknown) => asserts v = (value) => {};
+  other(x: unknown) {
+    this.assert(x); // ok
+    x;
+  }
+}
+
+declare class ParentInheritedPropertyDeclaration {
+  assert: (value: unknown) => asserts value;
+}
+class ChildInheritedPropertyDeclaration extends ParentInheritedPropertyDeclaration {
+  other(x: unknown) {
+    this.assert(x); // ok
+    x;
+  }
+}
+
+interface TestPropertySignature {
+  assert: (value: unknown) => asserts value;
+}
+function testPropertySignature(
+  x: TestPropertySignature,
+  y: unknown,
+) {
+  x.assert(y); // ok
+  x;
+}
+function testFunctionThisParameter1(
+  this: TestPropertySignature,
+  x: unknown,
+) {
+  this.assert(x); // ok
+  x;
+}
+
+interface TestMethodSignature {
+  assert(value: unknown): asserts value;
+}
+function testMethodSignature(
+  x: TestMethodSignature,
+  y: unknown,
+) {
+  x.assert(y); // ok
+  x;
+}
+function testFunctionThisParameter2(
+  this: TestMethodSignature,
+  x: unknown,
+) {
+  this.assert(x); // ok
+  x;
+}
 
 
 //// [assertionTypePredicates1.js]
@@ -386,6 +448,53 @@ function example1(things) {
         thing.good;
     }
 }
+var TestPropertyDeclaration1 = /** @class */ (function () {
+    function TestPropertyDeclaration1() {
+        this.assert = function (value) { };
+    }
+    TestPropertyDeclaration1.prototype.other = function (x) {
+        this.assert(x); // error
+        x;
+    };
+    return TestPropertyDeclaration1;
+}());
+var TestPropertyDeclaration2 = /** @class */ (function () {
+    function TestPropertyDeclaration2() {
+        this.assert = function (value) { };
+    }
+    TestPropertyDeclaration2.prototype.other = function (x) {
+        this.assert(x); // ok
+        x;
+    };
+    return TestPropertyDeclaration2;
+}());
+var ChildInheritedPropertyDeclaration = /** @class */ (function (_super) {
+    __extends(ChildInheritedPropertyDeclaration, _super);
+    function ChildInheritedPropertyDeclaration() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ChildInheritedPropertyDeclaration.prototype.other = function (x) {
+        this.assert(x); // ok
+        x;
+    };
+    return ChildInheritedPropertyDeclaration;
+}(ParentInheritedPropertyDeclaration));
+function testPropertySignature(x, y) {
+    x.assert(y); // ok
+    x;
+}
+function testFunctionThisParameter1(x) {
+    this.assert(x); // ok
+    x;
+}
+function testMethodSignature(x, y) {
+    x.assert(y); // ok
+    x;
+}
+function testFunctionThisParameter2(x) {
+    this.assert(x); // ok
+    x;
+}
 
 
 //// [assertionTypePredicates1.d.ts]
@@ -438,3 +547,27 @@ interface GoodThing {
     good: true;
 }
 declare function example1(things: Thing[]): void;
+declare class TestPropertyDeclaration1 {
+    assert: (value: unknown) => asserts value;
+    other(x: unknown): void;
+}
+declare class TestPropertyDeclaration2 {
+    assert: (v: unknown) => asserts v;
+    other(x: unknown): void;
+}
+declare class ParentInheritedPropertyDeclaration {
+    assert: (value: unknown) => asserts value;
+}
+declare class ChildInheritedPropertyDeclaration extends ParentInheritedPropertyDeclaration {
+    other(x: unknown): void;
+}
+interface TestPropertySignature {
+    assert: (value: unknown) => asserts value;
+}
+declare function testPropertySignature(x: TestPropertySignature, y: unknown): void;
+declare function testFunctionThisParameter1(this: TestPropertySignature, x: unknown): void;
+interface TestMethodSignature {
+    assert(value: unknown): asserts value;
+}
+declare function testMethodSignature(x: TestMethodSignature, y: unknown): void;
+declare function testFunctionThisParameter2(this: TestMethodSignature, x: unknown): void;