Enable method signature completion for object literals

src/compiler/types.ts

@@ -8756,6 +8756,7 @@ namespace ts {
         readonly includeAutomaticOptionalChainCompletions?: boolean;
         readonly includeCompletionsWithInsertText?: boolean;
         readonly includeCompletionsWithClassMemberSnippets?: boolean;
+        readonly includeCompletionsWithObjectLiteralMethodSnippets?: boolean;
         readonly allowIncompleteCompletions?: boolean;
         readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative";
         /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */

src/harness/fourslashImpl.ts

@@ -960,36 +960,36 @@ namespace FourSlash {
             expected = typeof expected === "string" ? { name: expected } : expected;
 
             if (actual.insertText !== expected.insertText) {
-                this.raiseError(`Completion insert text did not match: ${showTextDiff(expected.insertText || "", actual.insertText || "")}`);
+                this.raiseError(`At entry ${actual.name}: Completion insert text did not match: ${showTextDiff(expected.insertText || "", actual.insertText || "")}`);
             }
             const convertedReplacementSpan = expected.replacementSpan && ts.createTextSpanFromRange(expected.replacementSpan);
             if (convertedReplacementSpan?.length) {
                 try {
                     assert.deepEqual(actual.replacementSpan, convertedReplacementSpan);
                 }
                 catch {
-                    this.raiseError(`Expected completion replacementSpan to be ${stringify(convertedReplacementSpan)}, got ${stringify(actual.replacementSpan)}`);
+                    this.raiseError(`At entry ${actual.name}: Expected completion replacementSpan to be ${stringify(convertedReplacementSpan)}, got ${stringify(actual.replacementSpan)}`);
                 }
             }
 
             if (expected.kind !== undefined || expected.kindModifiers !== undefined) {
-                assert.equal(actual.kind, expected.kind, `Expected 'kind' for ${actual.name} to match`);
-                assert.equal(actual.kindModifiers, expected.kindModifiers || "", `Expected 'kindModifiers' for ${actual.name} to match`);
+                assert.equal(actual.kind, expected.kind, `At entry ${actual.name}: Expected 'kind' for ${actual.name} to match`);
+                assert.equal(actual.kindModifiers, expected.kindModifiers || "", `At entry ${actual.name}:  Expected 'kindModifiers' for ${actual.name} to match`);
             }
             if (expected.isFromUncheckedFile !== undefined) {
-                assert.equal<boolean | undefined>(actual.isFromUncheckedFile, expected.isFromUncheckedFile, "Expected 'isFromUncheckedFile' properties to match");
+                assert.equal<boolean | undefined>(actual.isFromUncheckedFile, expected.isFromUncheckedFile, `At entry ${actual.name}: Expected 'isFromUncheckedFile' properties to match`);
             }
             if (expected.isPackageJsonImport !== undefined) {
-                assert.equal<boolean | undefined>(actual.isPackageJsonImport, expected.isPackageJsonImport, "Expected 'isPackageJsonImport' properties to match");
+                assert.equal<boolean | undefined>(actual.isPackageJsonImport, expected.isPackageJsonImport, `At entry ${actual.name}: Expected 'isPackageJsonImport' properties to match`);
             }
 
-            assert.equal(actual.hasAction, expected.hasAction, `Expected 'hasAction' properties to match`);
-            assert.equal(actual.isRecommended, expected.isRecommended, `Expected 'isRecommended' properties to match'`);
-            assert.equal(actual.isSnippet, expected.isSnippet, `Expected 'isSnippet' properties to match`);
-            assert.equal(actual.source, expected.source, `Expected 'source' values to match`);
-            assert.equal(actual.sortText, expected.sortText || ts.Completions.SortText.LocationPriority, `Expected 'sortText' properties to match`);
+            assert.equal(actual.hasAction, expected.hasAction, `At entry ${actual.name}: Expected 'hasAction' properties to match`);
+            assert.equal(actual.isRecommended, expected.isRecommended, `At entry ${actual.name}: Expected 'isRecommended' properties to match'`);
+            assert.equal(actual.isSnippet, expected.isSnippet, `At entry ${actual.name}: Expected 'isSnippet' properties to match`);
+            assert.equal(actual.source, expected.source, `At entry ${actual.name}: Expected 'source' values to match`);
+            assert.equal(actual.sortText, expected.sortText || ts.Completions.SortText.LocationPriority, `At entry ${actual.name}: Expected 'sortText' properties to match`);
             if (expected.sourceDisplay && actual.sourceDisplay) {
-                assert.equal(ts.displayPartsToString(actual.sourceDisplay), expected.sourceDisplay, `Expected 'sourceDisplay' properties to match`);
+                assert.equal(ts.displayPartsToString(actual.sourceDisplay), expected.sourceDisplay, `At entry ${actual.name}: Expected 'sourceDisplay' properties to match`);
             }
 
             if (expected.text !== undefined) {

src/harness/fourslashInterfaceImpl.ts

@@ -950,9 +950,36 @@ namespace FourSlashInterface {
     }
 
     export namespace Completion {
-        export import SortText = ts.Completions.SortText;
+        import SortTextType = ts.Completions.SortText;
+        export type SortText = SortTextType;
         export import CompletionSource = ts.Completions.CompletionSource;
 
+        export const SortText = {
+            // Presets
+            LocalDeclarationPriority: "10" as SortText,
+            LocationPriority: "11" as SortText,
+            OptionalMember: "12" as SortText,
+            MemberDeclaredBySpreadAssignment: "13" as SortText,
+            SuggestedClassMembers: "14" as SortText,
+            GlobalsOrKeywords: "15" as SortText,
+            AutoImportSuggestions: "16" as SortText,
+            ClassMemberSnippets: "17" as SortText,
+            JavascriptIdentifiers: "18" as SortText,
+
+            // Transformations
+            Deprecated(sortText: SortText): SortText {
+                return "z" + sortText as SortText;
+            },
+
+            ObjectLiteralProperty(presetSortText: SortText, symbolDisplayName: string): SortText {
+                return `${presetSortText}\0${symbolDisplayName}\0` as SortText;
+            },
+
+            SortBelow(sortText: SortText): SortText {
+                return sortText + "1" as SortText;
+            },
+        };
+
         const functionEntry = (name: string): ExpectedCompletionEntryObject => ({
             name,
             kind: "function",
@@ -963,7 +990,7 @@ namespace FourSlashInterface {
             name,
             kind: "function",
             kindModifiers: "deprecated,declare",
-            sortText: SortText.DeprecatedGlobalsOrKeywords
+            sortText: "z15" as SortText,
         });
         const varEntry = (name: string): ExpectedCompletionEntryObject => ({
             name,
@@ -992,7 +1019,7 @@ namespace FourSlashInterface {
             name,
             kind: "method",
             kindModifiers: "deprecated,declare",
-            sortText: SortText.DeprecatedLocationPriority
+            sortText: "z11" as SortText,
         });
         const propertyEntry = (name: string): ExpectedCompletionEntryObject => ({
             name,

src/services/codefixes/helpers.ts

@@ -367,10 +367,10 @@ namespace ts.codefix {
         return parameters;
     }
 
-    function createMethodImplementingSignatures(
+    export function createMethodImplementingSignatures(
         checker: TypeChecker,
         context: TypeConstructionContext,
-        enclosingDeclaration: ClassLikeDeclaration,
+        enclosingDeclaration: Node,
         signatures: readonly Signature[],
         name: PropertyName,
         optional: boolean,
@@ -421,7 +421,7 @@ namespace ts.codefix {
             body);
     }
 
-    function getReturnTypeFromSignatures(signatures: readonly Signature[], checker: TypeChecker, context: TypeConstructionContext, enclosingDeclaration: ClassLikeDeclaration): TypeNode | undefined {
+    function getReturnTypeFromSignatures(signatures: readonly Signature[], checker: TypeChecker, context: TypeConstructionContext, enclosingDeclaration: Node): TypeNode | undefined {
         if (length(signatures)) {
             const type = checker.getUnionType(map(signatures, checker.getReturnTypeOfSignature));
             return checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context));