Disallows async abstract method declarations

Since we do not allow `async` as a modifier on type members such as in an interface, it was decided that it should also not be allowed on abstract methods.

Fixes microsoft#28516.

Author: aleph-naught2tog

src/compiler/checker.ts

@@ -28342,6 +28342,9 @@ namespace ts {
                             if (flags & ModifierFlags.Private) {
                                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
                             }
+                            if (flags & ModifierFlags.Async) {
+                                return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
+                            }
                         }
 
                         flags |= ModifierFlags.Abstract;

tests/baselines/reference/abstractAsync.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/compiler/abstractAsync.ts(2,9): error TS1243: 'async' modifier cannot be used with 'abstract' modifier.
+
+
+==== tests/cases/compiler/abstractAsync.ts (1 errors) ====
+    abstract class ShouldFailClass {
+      async abstract badMethod(): Promise<number>;
+            ~~~~~~~~
+!!! error TS1243: 'async' modifier cannot be used with 'abstract' modifier.
+    }

tests/baselines/reference/abstractAsync.js

@@ -0,0 +1,11 @@
+//// [abstractAsync.ts]
+abstract class ShouldFailClass {
+  async abstract badMethod(): Promise<number>;
+}
+
+//// [abstractAsync.js]
+var ShouldFailClass = /** @class */ (function () {
+    function ShouldFailClass() {
+    }
+    return ShouldFailClass;
+}());

tests/baselines/reference/abstractAsync.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/abstractAsync.ts ===
+abstract class ShouldFailClass {
+>ShouldFailClass : Symbol(ShouldFailClass, Decl(abstractAsync.ts, 0, 0))
+
+  async abstract badMethod(): Promise<number>;
+>badMethod : Symbol(ShouldFailClass.badMethod, Decl(abstractAsync.ts, 0, 32))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+}

tests/baselines/reference/abstractAsync.types

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/abstractAsync.ts ===
+abstract class ShouldFailClass {
+>ShouldFailClass : ShouldFailClass
+
+  async abstract badMethod(): Promise<number>;
+>badMethod : () => Promise<number>
+>Promise : Promise<T>
+}

tests/cases/compiler/abstractAsync.ts

@@ -0,0 +1,4 @@
+// @lib: es2015
+abstract class ShouldFailClass {
+  async abstract badMethod(): Promise<number>;
+}