Merge branch 'main' into release-5.3

Author: DanielRosenwasser

.dprint.jsonc

@@ -51,7 +51,7 @@
     ],
     // Note: if adding new languages, make sure settings.template.json is updated too.
     "plugins": [
-        "https://plugins.dprint.dev/typescript-0.87.1.wasm",
+        "https://plugins.dprint.dev/typescript-0.88.1.wasm",
         "https://plugins.dprint.dev/prettier-0.27.0.json@3557a62b4507c55a47d8cde0683195b14d13c41dda66d0f0b0e111aed107e2fe",
         "https://plugins.dprint.dev/json-0.17.4.wasm"
     ]

.github/workflows/new-release-branch.yaml

@@ -21,15 +21,15 @@ jobs:
       contents: write
 
     steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 5
       - uses: actions/setup-node@v3
       - run: |
           npm --version
           # corepack enable npm
           npm install -g $(jq -r '.packageManager' < package.json)
           npm --version
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 5
       - run: |
           git checkout -b ${{ github.event.client_payload.branch_name }}
           sed -i -e 's/"version": ".*"/"version": "${{ github.event.client_payload.package_version }}"/g' package.json

.github/workflows/set-version.yaml

@@ -21,10 +21,10 @@ jobs:
       contents: write
 
     steps:
-      - uses: actions/setup-node@v3
       - uses: actions/checkout@v3
         with:
           ref: ${{ github.event.client_payload.branch_name }}
+      - uses: actions/setup-node@v3
       - run: |
           npm --version
           # corepack enable npm

package-lock.json

@@ -1920,7 +1920,7 @@
         "category": "Error",
         "code": 2358
     },
-    "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type.": {
+    "The right-hand side of an 'instanceof' expression must be either of type 'any', a class, function, or other type assignable to the 'Function' interface type, or an object type with a 'Symbol.hasInstance' method.": {
         "category": "Error",
         "code": 2359
     },
@@ -3691,6 +3691,14 @@
         "category": "Error",
         "code": 2859
     },
+    "The left-hand side of an 'instanceof' expression must be assignable to the first argument of the right-hand side's '[Symbol.hasInstance]' method.": {
+        "category": "Error",
+        "code": 2860
+    },
+    "An object's '[Symbol.hasInstance]' method must return a boolean value for it to be used on the right-hand side of an 'instanceof' expression.": {
+        "category": "Error",
+        "code": 2861
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/checker.ts

@@ -3053,12 +3053,17 @@ export interface TaggedTemplateExpression extends MemberExpression {
     /** @internal */ questionDotToken?: QuestionDotToken; // NOTE: Invalid syntax, only used to report a grammar error.
 }
 
+export interface InstanceofExpression extends BinaryExpression {
+    readonly operatorToken: Token<SyntaxKind.InstanceOfKeyword>;
+}
+
 export type CallLikeExpression =
     | CallExpression
     | NewExpression
     | TaggedTemplateExpression
     | Decorator
-    | JsxOpeningLikeElement;
+    | JsxOpeningLikeElement
+    | InstanceofExpression;
 
 export interface AsExpression extends Expression {
     readonly kind: SyntaxKind.AsExpression;

src/compiler/diagnosticMessages.json

@@ -231,6 +231,7 @@ import {
     IndexSignatureDeclaration,
     InitializedVariableDeclaration,
     insertSorted,
+    InstanceofExpression,
     InterfaceDeclaration,
     InternalEmitFlags,
     isAccessor,
@@ -3120,6 +3121,8 @@ export function getInvokedExpression(node: CallLikeExpression): Expression | Jsx
         case SyntaxKind.JsxOpeningElement:
         case SyntaxKind.JsxSelfClosingElement:
             return node.tagName;
+        case SyntaxKind.BinaryExpression:
+            return node.right;
         default:
             return node.expression;
     }
@@ -7235,6 +7238,15 @@ export function isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(node
         || isPropertyAccessExpression(node.parent) && node.parent.name === node
         || isJSDocMemberName(node.parent) && node.parent.right === node;
 }
+/** @internal */
+export function isInstanceOfExpression(node: Node): node is InstanceofExpression {
+    return isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.InstanceOfKeyword;
+}
+
+/** @internal */
+export function isRightSideOfInstanceofExpression(node: Node) {
+    return isInstanceOfExpression(node.parent) && node === node.parent.right;
+}
 
 /** @internal */
 export function isEmptyObjectLiteral(expression: Node): boolean {

src/compiler/types.ts

@@ -102,7 +102,9 @@ import {
     isArrowFunction,
     isAssignmentExpression,
     isBinaryExpression,
+    isBindableStaticAccessExpression,
     isBindableStaticElementAccessExpression,
+    isBindableStaticNameExpression,
     isBindingElement,
     isBlock,
     isCallExpression,
@@ -111,6 +113,7 @@ import {
     isClassStaticBlockDeclaration,
     isDecorator,
     isElementAccessExpression,
+    isExpandoPropertyDeclaration,
     isExportAssignment,
     isExportDeclaration,
     isExportSpecifier,
@@ -153,6 +156,7 @@ import {
     isPropertyAccessExpression,
     isPropertyAssignment,
     isPropertyDeclaration,
+    isPrototypeAccess,
     isRootedDiskPath,
     isSourceFile,
     isStringLiteral,
@@ -1705,7 +1709,10 @@ export function isAutoAccessorPropertyDeclaration(node: Node): node is AutoAcces
 }
 
 /** @internal */
-export function isClassFieldAndNotAutoAccessor(node: Node): boolean {
+export function isClassInstanceProperty(node: Declaration): boolean {
+    if (isInJSFile(node) && isExpandoPropertyDeclaration(node)) {
+        return (!isBindableStaticAccessExpression(node) || !isPrototypeAccess(node.expression)) && !isBindableStaticNameExpression(node, /*excludeThisKeyword*/ true);
+    }
     return node.parent && isClassLike(node.parent) && isPropertyDeclaration(node) && !hasAccessorModifier(node);
 }
 

src/compiler/utilities.ts

@@ -10,8 +10,6 @@ import ArrayOrSingle = FourSlashInterface.ArrayOrSingle;
 
 export const enum FourSlashTestType {
     Native,
-    Shims,
-    ShimsWithPreprocess,
     Server,
 }
 
@@ -202,6 +200,32 @@ const enum CallHierarchyItemDirection {
     Outgoing,
 }
 
+interface RealizedDiagnostic {
+    message: string;
+    start: number;
+    length: number;
+    category: string;
+    code: number;
+    reportsUnnecessary?: {};
+    reportsDeprecated?: {};
+}
+
+function realizeDiagnostics(diagnostics: readonly ts.Diagnostic[], newLine: string): RealizedDiagnostic[] {
+    return diagnostics.map(d => realizeDiagnostic(d, newLine));
+}
+
+function realizeDiagnostic(diagnostic: ts.Diagnostic, newLine: string): RealizedDiagnostic {
+    return {
+        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, newLine),
+        start: diagnostic.start!, // TODO: GH#18217
+        length: diagnostic.length!, // TODO: GH#18217
+        category: ts.diagnosticCategoryName(diagnostic),
+        code: diagnostic.code,
+        reportsUnnecessary: diagnostic.reportsUnnecessary,
+        reportsDeprecated: diagnostic.reportsDeprecated,
+    };
+}
+
 export class TestState {
     // Language service instance
     private languageServiceAdapterHost: Harness.LanguageService.LanguageServiceAdapterHost;
@@ -267,10 +291,6 @@ export class TestState {
         switch (testType) {
             case FourSlashTestType.Native:
                 return new Harness.LanguageService.NativeLanguageServiceAdapter(cancellationToken, compilationOptions);
-            case FourSlashTestType.Shims:
-                return new Harness.LanguageService.ShimLanguageServiceAdapter(/*preprocessToResolve*/ false, cancellationToken, compilationOptions);
-            case FourSlashTestType.ShimsWithPreprocess:
-                return new Harness.LanguageService.ShimLanguageServiceAdapter(/*preprocessToResolve*/ true, cancellationToken, compilationOptions);
             case FourSlashTestType.Server:
                 return new Harness.LanguageService.ServerLanguageServiceAdapter(cancellationToken, compilationOptions);
             default:
@@ -1764,8 +1784,8 @@ export class TestState {
 
     private testDiagnostics(expected: readonly FourSlashInterface.Diagnostic[], diagnostics: readonly ts.Diagnostic[], category: string) {
         assert.deepEqual(
-            ts.realizeDiagnostics(diagnostics, "\n"),
-            expected.map((e): ts.RealizedDiagnostic => {
+            realizeDiagnostics(diagnostics, "\n"),
+            expected.map((e): RealizedDiagnostic => {
                 const range = e.range || this.getRangesInFile()[0];
                 if (!range) {
                     this.raiseError("Must provide a range for each expected diagnostic, or have one range in the fourslash source.");