Merge remote-tracking branch 'origin/main' into release-4.4

package-lock.json

@@ -325,9 +325,9 @@
             }
         },
         "@octokit/openapi-types": {
-            "version": "7.3.5",
-            "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-7.3.5.tgz",
-            "integrity": "sha512-6bm5lzGDOeSnWHM5W8OZ86RD2KpchynU+/Qlm5hNEFjfLDhwfAY2lSe68YRUEYFGlxSHe0HmakyhvmtWoD3Zog==",
+            "version": "7.4.0",
+            "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-7.4.0.tgz",
+            "integrity": "sha512-V2qNML1knHjrjTJcIIvhYZSTkvtSAoQpNEX8y0ykTJI8vOQPqIh0y6Jf9EU6c/y+v0c9+LeC1acwLQh1xo96MA==",
             "dev": true
         },
         "@octokit/plugin-paginate-rest": {
@@ -401,12 +401,12 @@
             }
         },
         "@octokit/types": {
-            "version": "6.16.7",
-            "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.16.7.tgz",
-            "integrity": "sha512-OuQELiwIKeDySgNID52vm33wDRc2aaX8lKYgAw9Hmw939ITow1HspT8/AH3M3jgGFUMDmHlMNBNEmH7xV7ggXQ==",
+            "version": "6.17.1",
+            "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.17.1.tgz",
+            "integrity": "sha512-x1RDwjjSzGHK8hfwyNa4Gz0t5YtwUfIxEtejFpm2cjH1gMMk6XDv8La3gUAPzYpDgdzTEF8Lpz+7BGv9aZR/0w==",
             "dev": true,
             "requires": {
-                "@octokit/openapi-types": "^7.3.5"
+                "@octokit/openapi-types": "^7.4.0"
             }
         },
         "@types/browserify": {

scripts/eslint/rules/boolean-trivia.ts

@@ -23,7 +23,7 @@ export = createRule({
         const sourceCodeText = sourceCode.getText();
 
         const isSetOrAssert = (name: string): boolean => name.startsWith("set") || name.startsWith("assert");
-        const isTrivia = (node: TSESTree.CallExpressionArgument): boolean => {
+        const isTrivia = (node: TSESTree.Node): boolean => {
             if (node.type === AST_NODE_TYPES.Identifier) {
                 return node.name === "undefined";
             }
@@ -69,7 +69,7 @@ export = createRule({
             return false;
         };
 
-        const checkArg = (node: TSESTree.CallExpressionArgument): void => {
+        const checkArg = (node: TSESTree.Node): void => {
             if (!isTrivia(node)) {
                 return;
             }

src/compiler/checker.ts

@@ -12106,7 +12106,7 @@ namespace ts {
         }
 
         function getApplicableIndexInfoForName(type: Type, name: __String): IndexInfo | undefined {
-            return getApplicableIndexInfo(type, getStringLiteralType(unescapeLeadingUnderscores(name)));
+            return getApplicableIndexInfo(type, isLateBoundName(name) ? esSymbolType : getStringLiteralType(unescapeLeadingUnderscores(name)));
         }
 
         // Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual
@@ -27121,8 +27121,12 @@ namespace ts {
          */
         function isKnownProperty(targetType: Type, name: __String, isComparingJsxAttributes: boolean): boolean {
             if (targetType.flags & TypeFlags.Object) {
+                // For backwards compatibility a symbol-named property is satisfied by a string index signature. This
+                // is incorrect and inconsistent with element access expressions, where it is an error, so eventually
+                // we should remove this exception.
                 if (getPropertyOfObjectType(targetType, name) ||
                     getApplicableIndexInfoForName(targetType, name) ||
+                    isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) ||
                     isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
                     // For JSXAttributes, if the attribute has a hyphenated name, consider that the attribute to be known.
                     return true;
@@ -28724,8 +28728,10 @@ namespace ts {
          * Returns the this argument in calls like x.f(...) and x[f](...). Undefined otherwise.
          */
         function getThisArgumentOfCall(node: CallLikeExpression): LeftHandSideExpression | undefined {
-            if (node.kind === SyntaxKind.CallExpression) {
-                const callee = skipOuterExpressions(node.expression);
+            const expression = node.kind === SyntaxKind.CallExpression ? node.expression :
+                node.kind === SyntaxKind.TaggedTemplateExpression ? node.tag : undefined;
+            if (expression) {
+                const callee = skipOuterExpressions(expression);
                 if (isAccessExpression(callee)) {
                     return callee.expression;
                 }
@@ -31403,8 +31409,9 @@ namespace ts {
         }
 
         function checkDeleteExpressionMustBeOptional(expr: AccessExpression, type: Type) {
-            const AnyOrUnknownOrNeverFlags = TypeFlags.AnyOrUnknown | TypeFlags.Never;
-            if (strictNullChecks && !(type.flags & AnyOrUnknownOrNeverFlags) && !(getFalsyFlags(type) & TypeFlags.Undefined)) {
+            if (strictNullChecks &&
+                !(type.flags & (TypeFlags.AnyOrUnknown | TypeFlags.Never)) &&
+                !(exactOptionalPropertyTypes ? 0 : getFalsyFlags(type) & TypeFlags.Undefined)) {
                 error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
             }
         }

src/server/scriptVersionCache.ts

@@ -67,10 +67,8 @@ namespace ts.server {
             }
             const lm = LineIndex.linesFromText(insertedText);
             const lines = lm.lines;
-            if (lines.length > 1) {
-                if (lines[lines.length - 1] === "") {
-                    lines.pop();
-                }
+            if (lines.length > 1 && lines[lines.length - 1] === "") {
+                lines.pop();
             }
             let branchParent: LineNode | undefined;
             let lastZeroCount: LineCollection | undefined;
@@ -683,8 +681,12 @@ namespace ts.server {
             }
 
             // Skipped all children
-            const { leaf } = this.lineNumberToInfo(this.lineCount(), 0);
-            return { oneBasedLine: this.lineCount(), zeroBasedColumn: leaf ? leaf.charCount() : 0, lineText: undefined };
+            const lineCount = this.lineCount();
+            if (lineCount === 0) { // it's empty! (and lineNumberToInfo expects a one-based line)
+                return { oneBasedLine: 1, zeroBasedColumn: 0, lineText: undefined };
+            }
+            const leaf = Debug.checkDefined(this.lineNumberToInfo(lineCount, 0).leaf);
+            return { oneBasedLine: lineCount, zeroBasedColumn: leaf.charCount(), lineText: undefined };
         }
 
         /**

src/testRunner/compilerRunner.ts

@@ -136,6 +136,7 @@ namespace Harness {
             "skipDefaultLibCheck",
             "preserveConstEnums",
             "skipLibCheck",
+            "exactOptionalPropertyTypes"
         ];
         private fileName: string;
         private justName: string;

src/testRunner/unittests/tsserver/versionCache.ts

@@ -52,6 +52,18 @@ var q:Point=<Point>p;`;
             assert.deepEqual(lineIndex.positionToLineOffset(0), { line: 1, offset: 1 });
         });
 
+        it("handles emptying whole file (GH#44518)", () => {
+            // See below for the main thing that this tests; it would be better to have a test
+            // that uses `ScriptInfo.positionToLineOffset` but I couldn't find away to do that
+            const { lines } = server.LineIndex.linesFromText("function foo() {\n\ndsa\n\n}\n\nfo(dsa\n\n\n    ");
+            const lineIndex = new server.LineIndex();
+            lineIndex.load(lines);
+            const snapshot = lineIndex.edit(0, 39);
+            assert.equal(snapshot.getText(0, snapshot.getLength()), "");
+            // line must always be >=1, otherwise the failIfInvalidLocation(location) assertion in ScriptInfo.positionToLineOffset will fail
+            assert.deepEqual(snapshot.positionToLineOffset(0), { line: 1, offset: 1 });
+        });
+
         it(`change 9 1 0 1 {"y"}`, () => {
             validateEditAtLineCharIndex(9, 1, 0, "y");
         });

tests/baselines/reference/deleteExpressionMustBeOptional(strict=false).errors.txt

@@ -43,4 +43,5 @@ tests/cases/compiler/deleteExpressionMustBeOptional.ts(34,10): error TS2339: Pro
     delete a.b
     
     delete b.a
-    delete b.b
+    delete b.b
+    

tests/baselines/reference/deleteExpressionMustBeOptional(strict=false).js

@@ -38,7 +38,8 @@ delete a.a
 delete a.b
 
 delete b.a
-delete b.b
+delete b.b
+
 
 //// [deleteExpressionMustBeOptional.js]
 delete f.a;

tests/baselines/reference/deleteExpressionMustBeOptional(strict=true).errors.txt

@@ -49,4 +49,5 @@ tests/cases/compiler/deleteExpressionMustBeOptional.ts(34,10): error TS2339: Pro
     delete a.b
     
     delete b.a
-    delete b.b
+    delete b.b
+    

tests/baselines/reference/deleteExpressionMustBeOptional(strict=true).js

@@ -38,7 +38,8 @@ delete a.a
 delete a.b
 
 delete b.a
-delete b.b
+delete b.b
+
 
 //// [deleteExpressionMustBeOptional.js]
 "use strict";

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).errors.txt

@@ -0,0 +1,53 @@
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(25,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(27,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(34,10): error TS2339: Property 'j' does not exist on type 'Foo'.
+
+
+==== tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts (3 errors) ====
+    interface Foo {
+        a: number
+        b: number | undefined
+        c: number | null
+        d?: number
+        e: number | undefined | null
+        f?: number | undefined | null
+        g: unknown
+        h: any
+        i: never
+    }
+    
+    interface AA {
+        [s: string]: number
+    }
+    
+    type BB = {
+        [P in keyof any]: number
+    }
+    
+    declare const f: Foo
+    declare const a: AA
+    declare const b: BB
+    
+    delete f.a
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.b
+    delete f.c
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.d
+    delete f.e
+    delete f.f
+    delete f.g
+    delete f.h
+    delete f.i
+    delete f.j
+             ~
+!!! error TS2339: Property 'j' does not exist on type 'Foo'.
+    
+    delete a.a
+    delete a.b
+    
+    delete b.a
+    delete b.b
+    

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).js

@@ -0,0 +1,58 @@
+//// [deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts]
+interface Foo {
+    a: number
+    b: number | undefined
+    c: number | null
+    d?: number
+    e: number | undefined | null
+    f?: number | undefined | null
+    g: unknown
+    h: any
+    i: never
+}
+
+interface AA {
+    [s: string]: number
+}
+
+type BB = {
+    [P in keyof any]: number
+}
+
+declare const f: Foo
+declare const a: AA
+declare const b: BB
+
+delete f.a
+delete f.b
+delete f.c
+delete f.d
+delete f.e
+delete f.f
+delete f.g
+delete f.h
+delete f.i
+delete f.j
+
+delete a.a
+delete a.b
+
+delete b.a
+delete b.b
+
+
+//// [deleteExpressionMustBeOptional_exactOptionalPropertyTypes.js]
+delete f.a;
+delete f.b;
+delete f.c;
+delete f.d;
+delete f.e;
+delete f.f;
+delete f.g;
+delete f.h;
+delete f.i;
+delete f.j;
+delete a.a;
+delete a.b;
+delete b.a;
+delete b.b;

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).symbols

@@ -0,0 +1,118 @@
+=== tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts ===
+interface Foo {
+>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 0))
+
+    a: number
+>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 15))
+
+    b: number | undefined
+>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 1, 13))
+
+    c: number | null
+>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 2, 25))
+
+    d?: number
+>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 3, 20))
+
+    e: number | undefined | null
+>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 4, 14))
+
+    f?: number | undefined | null
+>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 5, 32))
+
+    g: unknown
+>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 6, 33))
+
+    h: any
+>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 7, 14))
+
+    i: never
+>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 8, 10))
+}
+
+interface AA {
+>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 10, 1))
+
+    [s: string]: number
+>s : Symbol(s, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 13, 5))
+}
+
+type BB = {
+>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 14, 1))
+
+    [P in keyof any]: number
+>P : Symbol(P, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 17, 5))
+}
+
+declare const f: Foo
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 0))
+
+declare const a: AA
+>a : Symbol(a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 21, 13))
+>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 10, 1))
+
+declare const b: BB
+>b : Symbol(b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 22, 13))
+>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 14, 1))
+
+delete f.a
+>f.a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 15))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 15))
+
+delete f.b
+>f.b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 1, 13))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 1, 13))
+
+delete f.c
+>f.c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 2, 25))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 2, 25))
+
+delete f.d
+>f.d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 3, 20))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 3, 20))
+
+delete f.e
+>f.e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 4, 14))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 4, 14))
+
+delete f.f
+>f.f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 5, 32))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 5, 32))
+
+delete f.g
+>f.g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 6, 33))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 6, 33))
+
+delete f.h
+>f.h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 7, 14))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 7, 14))
+
+delete f.i
+>f.i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 8, 10))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 8, 10))
+
+delete f.j
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+
+delete a.a
+>a : Symbol(a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 21, 13))
+
+delete a.b
+>a : Symbol(a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 21, 13))
+
+delete b.a
+>b : Symbol(b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 22, 13))
+
+delete b.b
+>b : Symbol(b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 22, 13))
+

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=false).types

@@ -0,0 +1,137 @@
+=== tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts ===
+interface Foo {
+    a: number
+>a : number
+
+    b: number | undefined
+>b : number | undefined
+
+    c: number | null
+>c : number | null
+>null : null
+
+    d?: number
+>d : number | undefined
+
+    e: number | undefined | null
+>e : number | null | undefined
+>null : null
+
+    f?: number | undefined | null
+>f : number | null | undefined
+>null : null
+
+    g: unknown
+>g : unknown
+
+    h: any
+>h : any
+
+    i: never
+>i : never
+}
+
+interface AA {
+    [s: string]: number
+>s : string
+}
+
+type BB = {
+>BB : BB
+
+    [P in keyof any]: number
+}
+
+declare const f: Foo
+>f : Foo
+
+declare const a: AA
+>a : AA
+
+declare const b: BB
+>b : BB
+
+delete f.a
+>delete f.a : boolean
+>f.a : number
+>f : Foo
+>a : number
+
+delete f.b
+>delete f.b : boolean
+>f.b : number | undefined
+>f : Foo
+>b : number | undefined
+
+delete f.c
+>delete f.c : boolean
+>f.c : number | null
+>f : Foo
+>c : number | null
+
+delete f.d
+>delete f.d : boolean
+>f.d : number | undefined
+>f : Foo
+>d : number | undefined
+
+delete f.e
+>delete f.e : boolean
+>f.e : number | null | undefined
+>f : Foo
+>e : number | null | undefined
+
+delete f.f
+>delete f.f : boolean
+>f.f : number | null | undefined
+>f : Foo
+>f : number | null | undefined
+
+delete f.g
+>delete f.g : boolean
+>f.g : unknown
+>f : Foo
+>g : unknown
+
+delete f.h
+>delete f.h : boolean
+>f.h : any
+>f : Foo
+>h : any
+
+delete f.i
+>delete f.i : boolean
+>f.i : never
+>f : Foo
+>i : never
+
+delete f.j
+>delete f.j : boolean
+>f.j : any
+>f : Foo
+>j : any
+
+delete a.a
+>delete a.a : boolean
+>a.a : number
+>a : AA
+>a : number
+
+delete a.b
+>delete a.b : boolean
+>a.b : number
+>a : AA
+>b : number
+
+delete b.a
+>delete b.a : boolean
+>b.a : number
+>b : BB
+>a : number
+
+delete b.b
+>delete b.b : boolean
+>b.b : number
+>b : BB
+>b : number
+

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).errors.txt

@@ -0,0 +1,65 @@
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(25,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(26,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(27,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(28,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(29,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(30,8): error TS2790: The operand of a 'delete' operator must be optional.
+tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts(34,10): error TS2339: Property 'j' does not exist on type 'Foo'.
+
+
+==== tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts (7 errors) ====
+    interface Foo {
+        a: number
+        b: number | undefined
+        c: number | null
+        d?: number
+        e: number | undefined | null
+        f?: number | undefined | null
+        g: unknown
+        h: any
+        i: never
+    }
+    
+    interface AA {
+        [s: string]: number
+    }
+    
+    type BB = {
+        [P in keyof any]: number
+    }
+    
+    declare const f: Foo
+    declare const a: AA
+    declare const b: BB
+    
+    delete f.a
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.b
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.c
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.d
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.e
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.f
+           ~~~
+!!! error TS2790: The operand of a 'delete' operator must be optional.
+    delete f.g
+    delete f.h
+    delete f.i
+    delete f.j
+             ~
+!!! error TS2339: Property 'j' does not exist on type 'Foo'.
+    
+    delete a.a
+    delete a.b
+    
+    delete b.a
+    delete b.b
+    

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).js

@@ -0,0 +1,58 @@
+//// [deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts]
+interface Foo {
+    a: number
+    b: number | undefined
+    c: number | null
+    d?: number
+    e: number | undefined | null
+    f?: number | undefined | null
+    g: unknown
+    h: any
+    i: never
+}
+
+interface AA {
+    [s: string]: number
+}
+
+type BB = {
+    [P in keyof any]: number
+}
+
+declare const f: Foo
+declare const a: AA
+declare const b: BB
+
+delete f.a
+delete f.b
+delete f.c
+delete f.d
+delete f.e
+delete f.f
+delete f.g
+delete f.h
+delete f.i
+delete f.j
+
+delete a.a
+delete a.b
+
+delete b.a
+delete b.b
+
+
+//// [deleteExpressionMustBeOptional_exactOptionalPropertyTypes.js]
+delete f.a;
+delete f.b;
+delete f.c;
+delete f.d;
+delete f.e;
+delete f.f;
+delete f.g;
+delete f.h;
+delete f.i;
+delete f.j;
+delete a.a;
+delete a.b;
+delete b.a;
+delete b.b;

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).symbols

@@ -0,0 +1,118 @@
+=== tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts ===
+interface Foo {
+>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 0))
+
+    a: number
+>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 15))
+
+    b: number | undefined
+>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 1, 13))
+
+    c: number | null
+>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 2, 25))
+
+    d?: number
+>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 3, 20))
+
+    e: number | undefined | null
+>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 4, 14))
+
+    f?: number | undefined | null
+>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 5, 32))
+
+    g: unknown
+>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 6, 33))
+
+    h: any
+>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 7, 14))
+
+    i: never
+>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 8, 10))
+}
+
+interface AA {
+>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 10, 1))
+
+    [s: string]: number
+>s : Symbol(s, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 13, 5))
+}
+
+type BB = {
+>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 14, 1))
+
+    [P in keyof any]: number
+>P : Symbol(P, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 17, 5))
+}
+
+declare const f: Foo
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>Foo : Symbol(Foo, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 0))
+
+declare const a: AA
+>a : Symbol(a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 21, 13))
+>AA : Symbol(AA, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 10, 1))
+
+declare const b: BB
+>b : Symbol(b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 22, 13))
+>BB : Symbol(BB, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 14, 1))
+
+delete f.a
+>f.a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 15))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>a : Symbol(Foo.a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 0, 15))
+
+delete f.b
+>f.b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 1, 13))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>b : Symbol(Foo.b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 1, 13))
+
+delete f.c
+>f.c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 2, 25))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>c : Symbol(Foo.c, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 2, 25))
+
+delete f.d
+>f.d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 3, 20))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>d : Symbol(Foo.d, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 3, 20))
+
+delete f.e
+>f.e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 4, 14))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>e : Symbol(Foo.e, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 4, 14))
+
+delete f.f
+>f.f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 5, 32))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>f : Symbol(Foo.f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 5, 32))
+
+delete f.g
+>f.g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 6, 33))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>g : Symbol(Foo.g, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 6, 33))
+
+delete f.h
+>f.h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 7, 14))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>h : Symbol(Foo.h, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 7, 14))
+
+delete f.i
+>f.i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 8, 10))
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+>i : Symbol(Foo.i, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 8, 10))
+
+delete f.j
+>f : Symbol(f, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 20, 13))
+
+delete a.a
+>a : Symbol(a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 21, 13))
+
+delete a.b
+>a : Symbol(a, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 21, 13))
+
+delete b.a
+>b : Symbol(b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 22, 13))
+
+delete b.b
+>b : Symbol(b, Decl(deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts, 22, 13))
+

tests/baselines/reference/deleteExpressionMustBeOptional_exactOptionalPropertyTypes(exactoptionalpropertytypes=true).types

@@ -0,0 +1,137 @@
+=== tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts ===
+interface Foo {
+    a: number
+>a : number
+
+    b: number | undefined
+>b : number | undefined
+
+    c: number | null
+>c : number | null
+>null : null
+
+    d?: number
+>d : number | undefined
+
+    e: number | undefined | null
+>e : number | null | undefined
+>null : null
+
+    f?: number | undefined | null
+>f : number | null | undefined
+>null : null
+
+    g: unknown
+>g : unknown
+
+    h: any
+>h : any
+
+    i: never
+>i : never
+}
+
+interface AA {
+    [s: string]: number
+>s : string
+}
+
+type BB = {
+>BB : BB
+
+    [P in keyof any]: number
+}
+
+declare const f: Foo
+>f : Foo
+
+declare const a: AA
+>a : AA
+
+declare const b: BB
+>b : BB
+
+delete f.a
+>delete f.a : boolean
+>f.a : number
+>f : Foo
+>a : number
+
+delete f.b
+>delete f.b : boolean
+>f.b : number | undefined
+>f : Foo
+>b : number | undefined
+
+delete f.c
+>delete f.c : boolean
+>f.c : number | null
+>f : Foo
+>c : number | null
+
+delete f.d
+>delete f.d : boolean
+>f.d : number | undefined
+>f : Foo
+>d : number | undefined
+
+delete f.e
+>delete f.e : boolean
+>f.e : number | null | undefined
+>f : Foo
+>e : number | null | undefined
+
+delete f.f
+>delete f.f : boolean
+>f.f : number | null | undefined
+>f : Foo
+>f : number | null | undefined
+
+delete f.g
+>delete f.g : boolean
+>f.g : unknown
+>f : Foo
+>g : unknown
+
+delete f.h
+>delete f.h : boolean
+>f.h : any
+>f : Foo
+>h : any
+
+delete f.i
+>delete f.i : boolean
+>f.i : never
+>f : Foo
+>i : never
+
+delete f.j
+>delete f.j : boolean
+>f.j : any
+>f : Foo
+>j : any
+
+delete a.a
+>delete a.a : boolean
+>a.a : number
+>a : AA
+>a : number
+
+delete a.b
+>delete a.b : boolean
+>a.b : number
+>a : AA
+>b : number
+
+delete b.a
+>delete b.a : boolean
+>b.a : number
+>b : BB
+>a : number
+
+delete b.b
+>delete b.b : boolean
+>b.b : number
+>b : BB
+>b : number
+

tests/baselines/reference/indexSignatures1.errors.txt

@@ -68,9 +68,11 @@ tests/cases/conformance/types/members/indexSignatures1.ts(281,35): error TS2322:
   Object literal may only specify known properties, and ''someKey'' does not exist in type 'PseudoDeclaration'.
 tests/cases/conformance/types/members/indexSignatures1.ts(286,7): error TS2322: Type '"two"' is not assignable to type '`/${string}`'.
 tests/cases/conformance/types/members/indexSignatures1.ts(289,7): error TS2322: Type 'number' is not assignable to type 'PathsObject'.
+tests/cases/conformance/types/members/indexSignatures1.ts(312,43): error TS2322: Type '{ [sym]: string; }' is not assignable to type '{ [key: number]: string; }'.
+  Object literal may only specify known properties, and '[sym]' does not exist in type '{ [key: number]: string; }'.
 
 
-==== tests/cases/conformance/types/members/indexSignatures1.ts (49 errors) ====
+==== tests/cases/conformance/types/members/indexSignatures1.ts (50 errors) ====
     // Symbol index signature checking
     
     const sym = Symbol();
@@ -488,4 +490,21 @@ tests/cases/conformance/types/members/indexSignatures1.ts(289,7): error TS2322:
     const a: A = { [id]: 'test' }
     
     let aid = a[id];
+    
+    // Repro from #44793
+    
+    interface AA {
+        a?: string;
+        b?: number;
+        [key: symbol]: string;
+    }
+    
+    const aa: AA = { [sym]: '123' };
+    
+    const obj1: { [key: symbol]: string } = { [sym]: 'hello '};
+    const obj2: { [key: string]: string } = { [sym]: 'hello '};  // Permitted for backwards compatibility
+    const obj3: { [key: number]: string } = { [sym]: 'hello '};  // Error
+                                              ~~~~~~~~~~~~~~~
+!!! error TS2322: Type '{ [sym]: string; }' is not assignable to type '{ [key: number]: string; }'.
+!!! error TS2322:   Object literal may only specify known properties, and '[sym]' does not exist in type '{ [key: number]: string; }'.
     

tests/baselines/reference/indexSignatures1.js

@@ -297,6 +297,20 @@ type A = Record<IdType, string>;
 const a: A = { [id]: 'test' }
 
 let aid = a[id];
+
+// Repro from #44793
+
+interface AA {
+    a?: string;
+    b?: number;
+    [key: symbol]: string;
+}
+
+const aa: AA = { [sym]: '123' };
+
+const obj1: { [key: symbol]: string } = { [sym]: 'hello '};
+const obj2: { [key: string]: string } = { [sym]: 'hello '};  // Permitted for backwards compatibility
+const obj3: { [key: number]: string } = { [sym]: 'hello '};  // Error
 
 
 //// [indexSignatures1.js]
@@ -457,6 +471,10 @@ const pathObject = 123; // Error
 const id = '0000-0000-0000-0001';
 const a = { [id]: 'test' };
 let aid = a[id];
+const aa = { [sym]: '123' };
+const obj1 = { [sym]: 'hello ' };
+const obj2 = { [sym]: 'hello ' }; // Permitted for backwards compatibility
+const obj3 = { [sym]: 'hello ' }; // Error
 
 
 //// [indexSignatures1.d.ts]
@@ -627,3 +645,18 @@ declare const id: IdType;
 declare type A = Record<IdType, string>;
 declare const a: A;
 declare let aid: string;
+interface AA {
+    a?: string;
+    b?: number;
+    [key: symbol]: string;
+}
+declare const aa: AA;
+declare const obj1: {
+    [key: symbol]: string;
+};
+declare const obj2: {
+    [key: string]: string;
+};
+declare const obj3: {
+    [key: number]: string;
+};

tests/baselines/reference/indexSignatures1.symbols

@@ -860,3 +860,42 @@ let aid = a[id];
 >a : Symbol(a, Decl(indexSignatures1.ts, 295, 5))
 >id : Symbol(id, Decl(indexSignatures1.ts, 291, 5))
 
+// Repro from #44793
+
+interface AA {
+>AA : Symbol(AA, Decl(indexSignatures1.ts, 297, 16))
+
+    a?: string;
+>a : Symbol(AA.a, Decl(indexSignatures1.ts, 301, 14))
+
+    b?: number;
+>b : Symbol(AA.b, Decl(indexSignatures1.ts, 302, 15))
+
+    [key: symbol]: string;
+>key : Symbol(key, Decl(indexSignatures1.ts, 304, 5))
+}
+
+const aa: AA = { [sym]: '123' };
+>aa : Symbol(aa, Decl(indexSignatures1.ts, 307, 5))
+>AA : Symbol(AA, Decl(indexSignatures1.ts, 297, 16))
+>[sym] : Symbol([sym], Decl(indexSignatures1.ts, 307, 16))
+>sym : Symbol(sym, Decl(indexSignatures1.ts, 2, 5))
+
+const obj1: { [key: symbol]: string } = { [sym]: 'hello '};
+>obj1 : Symbol(obj1, Decl(indexSignatures1.ts, 309, 5))
+>key : Symbol(key, Decl(indexSignatures1.ts, 309, 15))
+>[sym] : Symbol([sym], Decl(indexSignatures1.ts, 309, 41))
+>sym : Symbol(sym, Decl(indexSignatures1.ts, 2, 5))
+
+const obj2: { [key: string]: string } = { [sym]: 'hello '};  // Permitted for backwards compatibility
+>obj2 : Symbol(obj2, Decl(indexSignatures1.ts, 310, 5))
+>key : Symbol(key, Decl(indexSignatures1.ts, 310, 15))
+>[sym] : Symbol([sym], Decl(indexSignatures1.ts, 310, 41))
+>sym : Symbol(sym, Decl(indexSignatures1.ts, 2, 5))
+
+const obj3: { [key: number]: string } = { [sym]: 'hello '};  // Error
+>obj3 : Symbol(obj3, Decl(indexSignatures1.ts, 311, 5))
+>key : Symbol(key, Decl(indexSignatures1.ts, 311, 15))
+>[sym] : Symbol([sym], Decl(indexSignatures1.ts, 311, 41))
+>sym : Symbol(sym, Decl(indexSignatures1.ts, 2, 5))
+

tests/baselines/reference/indexSignatures1.types

@@ -1007,3 +1007,47 @@ let aid = a[id];
 >a : A
 >id : `${number}-${number}-${number}-${number}`
 
+// Repro from #44793
+
+interface AA {
+    a?: string;
+>a : string | undefined
+
+    b?: number;
+>b : number | undefined
+
+    [key: symbol]: string;
+>key : symbol
+}
+
+const aa: AA = { [sym]: '123' };
+>aa : AA
+>{ [sym]: '123' } : { [sym]: string; }
+>[sym] : string
+>sym : unique symbol
+>'123' : "123"
+
+const obj1: { [key: symbol]: string } = { [sym]: 'hello '};
+>obj1 : { [key: symbol]: string; }
+>key : symbol
+>{ [sym]: 'hello '} : { [sym]: string; }
+>[sym] : string
+>sym : unique symbol
+>'hello ' : "hello "
+
+const obj2: { [key: string]: string } = { [sym]: 'hello '};  // Permitted for backwards compatibility
+>obj2 : { [key: string]: string; }
+>key : string
+>{ [sym]: 'hello '} : { [sym]: string; }
+>[sym] : string
+>sym : unique symbol
+>'hello ' : "hello "
+
+const obj3: { [key: number]: string } = { [sym]: 'hello '};  // Error
+>obj3 : { [key: number]: string; }
+>key : number
+>{ [sym]: 'hello '} : { [sym]: string; }
+>[sym] : string
+>sym : unique symbol
+>'hello ' : "hello "
+

tests/baselines/reference/thisTypeInTaggedTemplateCall.js

@@ -0,0 +1,19 @@
+//// [thisTypeInTaggedTemplateCall.ts]
+class Foo {
+    static m<T>(this: new () => T, strings: TemplateStringsArray | string) {
+        return new this()
+    }
+}
+
+Foo.m`test`;
+(Foo.m)`test`;
+
+
+//// [thisTypeInTaggedTemplateCall.js]
+class Foo {
+    static m(strings) {
+        return new this();
+    }
+}
+Foo.m `test`;
+(Foo.m) `test`;

tests/baselines/reference/thisTypeInTaggedTemplateCall.symbols

@@ -0,0 +1,27 @@
+=== tests/cases/conformance/types/thisType/thisTypeInTaggedTemplateCall.ts ===
+class Foo {
+>Foo : Symbol(Foo, Decl(thisTypeInTaggedTemplateCall.ts, 0, 0))
+
+    static m<T>(this: new () => T, strings: TemplateStringsArray | string) {
+>m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
+>T : Symbol(T, Decl(thisTypeInTaggedTemplateCall.ts, 1, 13))
+>this : Symbol(this, Decl(thisTypeInTaggedTemplateCall.ts, 1, 16))
+>T : Symbol(T, Decl(thisTypeInTaggedTemplateCall.ts, 1, 13))
+>strings : Symbol(strings, Decl(thisTypeInTaggedTemplateCall.ts, 1, 34))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.es5.d.ts, --, --))
+
+        return new this()
+>this : Symbol(this, Decl(thisTypeInTaggedTemplateCall.ts, 1, 16))
+    }
+}
+
+Foo.m`test`;
+>Foo.m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
+>Foo : Symbol(Foo, Decl(thisTypeInTaggedTemplateCall.ts, 0, 0))
+>m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
+
+(Foo.m)`test`;
+>Foo.m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
+>Foo : Symbol(Foo, Decl(thisTypeInTaggedTemplateCall.ts, 0, 0))
+>m : Symbol(Foo.m, Decl(thisTypeInTaggedTemplateCall.ts, 0, 11))
+

tests/baselines/reference/thisTypeInTaggedTemplateCall.types

@@ -0,0 +1,30 @@
+=== tests/cases/conformance/types/thisType/thisTypeInTaggedTemplateCall.ts ===
+class Foo {
+>Foo : Foo
+
+    static m<T>(this: new () => T, strings: TemplateStringsArray | string) {
+>m : <T>(this: new () => T, strings: TemplateStringsArray | string) => T
+>this : new () => T
+>strings : string | TemplateStringsArray
+
+        return new this()
+>new this() : T
+>this : new () => T
+    }
+}
+
+Foo.m`test`;
+>Foo.m`test` : Foo
+>Foo.m : <T>(this: new () => T, strings: string | TemplateStringsArray) => T
+>Foo : typeof Foo
+>m : <T>(this: new () => T, strings: string | TemplateStringsArray) => T
+>`test` : "test"
+
+(Foo.m)`test`;
+>(Foo.m)`test` : Foo
+>(Foo.m) : <T>(this: new () => T, strings: string | TemplateStringsArray) => T
+>Foo.m : <T>(this: new () => T, strings: string | TemplateStringsArray) => T
+>Foo : typeof Foo
+>m : <T>(this: new () => T, strings: string | TemplateStringsArray) => T
+>`test` : "test"
+

tests/cases/compiler/deleteExpressionMustBeOptional.ts

@@ -1,42 +1,42 @@
-// @strict: true, false
-
-interface Foo {
-    a: number
-    b: number | undefined
-    c: number | null
-    d?: number
-    e: number | undefined | null
-    f?: number | undefined | null
-    g: unknown
-    h: any
-    i: never
-}
-
-interface AA {
-    [s: string]: number
-}
-
-type BB = {
-    [P in keyof any]: number
-}
-
-declare const f: Foo
-declare const a: AA
-declare const b: BB
-
-delete f.a
-delete f.b
-delete f.c
-delete f.d
-delete f.e
-delete f.f
-delete f.g
-delete f.h
-delete f.i
-delete f.j
-
-delete a.a
-delete a.b
-
-delete b.a
-delete b.b
+// @strict: true, false
+
+interface Foo {
+    a: number
+    b: number | undefined
+    c: number | null
+    d?: number
+    e: number | undefined | null
+    f?: number | undefined | null
+    g: unknown
+    h: any
+    i: never
+}
+
+interface AA {
+    [s: string]: number
+}
+
+type BB = {
+    [P in keyof any]: number
+}
+
+declare const f: Foo
+declare const a: AA
+declare const b: BB
+
+delete f.a
+delete f.b
+delete f.c
+delete f.d
+delete f.e
+delete f.f
+delete f.g
+delete f.h
+delete f.i
+delete f.j
+
+delete a.a
+delete a.b
+
+delete b.a
+delete b.b

tests/cases/compiler/deleteExpressionMustBeOptional_exactOptionalPropertyTypes.ts

@@ -0,0 +1,43 @@
+// @strictNullChecks: true
+// @exactOptionalPropertyTypes: true, false
+
+interface Foo {
+    a: number
+    b: number | undefined
+    c: number | null
+    d?: number
+    e: number | undefined | null
+    f?: number | undefined | null
+    g: unknown
+    h: any
+    i: never
+}
+
+interface AA {
+    [s: string]: number
+}
+
+type BB = {
+    [P in keyof any]: number
+}
+
+declare const f: Foo
+declare const a: AA
+declare const b: BB
+
+delete f.a
+delete f.b
+delete f.c
+delete f.d
+delete f.e
+delete f.f
+delete f.g
+delete f.h
+delete f.i
+delete f.j
+
+delete a.a
+delete a.b
+
+delete b.a
+delete b.b

tests/cases/conformance/types/members/indexSignatures1.ts

@@ -300,3 +300,17 @@ type A = Record<IdType, string>;
 const a: A = { [id]: 'test' }
 
 let aid = a[id];
+
+// Repro from #44793
+
+interface AA {
+    a?: string;
+    b?: number;
+    [key: symbol]: string;
+}
+
+const aa: AA = { [sym]: '123' };
+
+const obj1: { [key: symbol]: string } = { [sym]: 'hello '};
+const obj2: { [key: string]: string } = { [sym]: 'hello '};  // Permitted for backwards compatibility
+const obj3: { [key: number]: string } = { [sym]: 'hello '};  // Error

tests/cases/conformance/types/thisType/thisTypeInTaggedTemplateCall.ts

@@ -0,0 +1,10 @@
+// @target: esnext
+
+class Foo {
+    static m<T>(this: new () => T, strings: TemplateStringsArray | string) {
+        return new this()
+    }
+}
+
+Foo.m`test`;
+(Foo.m)`test`;