fix(41259) : JS autocomplete doesn't work for object literal shorthands

src/services/completions.ts

@@ -1892,13 +1892,27 @@ namespace ts.Completions {
 
             if (objectLikeContainer.kind === SyntaxKind.ObjectLiteralExpression) {
                 const instantiatedType = tryGetObjectLiteralContextualType(objectLikeContainer, typeChecker);
+
+                // Check completions for Object property value shorthand
                 if (instantiatedType === undefined) {
-                    return GlobalsSearch.Fail;
+                    if (objectLikeContainer.flags & NodeFlags.InWithStatement) {
+                        return GlobalsSearch.Fail;
+                    }
+                    return GlobalsSearch.Continue;
                 }
                 const completionsType = typeChecker.getContextualType(objectLikeContainer, ContextFlags.Completions);
-                isNewIdentifierLocation = hasIndexSignature(completionsType || instantiatedType);
+                const hasStringIndexType = (completionsType || instantiatedType).getStringIndexType();
+                const hasNumberIndextype = (completionsType || instantiatedType).getNumberIndexType();
+                isNewIdentifierLocation = !!hasStringIndexType || !!hasNumberIndextype;
                 typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker);
                 existingMembers = objectLikeContainer.properties;
+
+                if (typeMembers.length === 0) {
+                    // Edge case: If NumberIndexType exists
+                    if (!hasNumberIndextype) {
+                        return GlobalsSearch.Continue;
+                    }
+                }
             }
             else {
                 Debug.assert(objectLikeContainer.kind === SyntaxKind.ObjectBindingPattern);
@@ -2312,6 +2326,7 @@ namespace ts.Completions {
             }
 
             return isDeclarationName(contextToken)
+                && !isShorthandPropertyAssignment(contextToken.parent)
                 && !isJsxAttribute(contextToken.parent)
                 // Don't block completions if we're in `class C /**/`, because we're *past* the end of the identifier and might want to complete `extends`.
                 // If `contextToken !== previousToken`, this is `class C ex/**/`.

tests/cases/fourslash/completionListAtIdentifierDefinitionLocations_destructuring.ts

@@ -1,19 +1,27 @@
 /// <reference path='fourslash.ts' />
 
+// @Filename: a.ts
 //// var [x/*variable1*/
 
+// @Filename: b.ts
 //// var [x, y/*variable2*/
 
+// @Filename: c.ts
 //// var [./*variable3*/
 
+// @Filename: d.ts
 //// var [x, ...z/*variable4*/
 
+// @Filename: e.ts
 //// var {x/*variable5*/
 
+// @Filename: f.ts
 //// var {x, y/*variable6*/
 
+// @Filename: g.ts
 //// function func1({ a/*parameter1*/
 
+// @Filename: h.ts
 //// function func2({ a, b/*parameter2*/
 
-verify.completions({ marker: test.markers(), exact: undefined });
+verify.completions({ marker: test.markers(), exact: undefined });

tests/cases/fourslash/completionPropertyShorthandForObjectLiteral.ts

@@ -0,0 +1,49 @@
+/// <reference path="fourslash.ts"/>
+
+//// declare const foo: number;
+//// interface Empty {}
+//// interface Typed { typed: number; }
+
+//// declare function f1(obj): void;
+//// declare function f2(obj: any): void;
+//// declare function f3(obj: unknown): void;
+//// declare function f4(obj: object): void;
+//// declare function f5(obj: Record<string, any>): void;
+//// declare function f6(obj: { [key: string]: number }): void;
+//// declare function f7<T>(obj: T): void;
+//// declare function f8<T extends object>(obj: T): void;
+//// declare function f9<T extends {}>(obj: T): void;
+//// declare function f10<T extends Empty>(obj: T): void;
+//// declare function f11<T extends (Empty | Record<string, any> | {})>(obj: T): void;
+//// declare function f12(obj: Object): void;
+//// declare function f13<T extends Object>(obj: T): void;
+//// declare function f14(obj: Typed): void;
+//// declare function f15<T extends (Empty | Object | Typed)>(obj: T): void;
+//// declare function f16(obj: Record<number, any>): void;
+//// declare function f17(obj: { [key: string]: number, prop: number }): void;
+//// declare function f18(obj: { [key: number]: number }): void;
+
+//// f1({f/*1*/});
+//// f2({f/*2*/});
+//// f3({f/*3*/});
+//// f4({f/*4*/});
+//// f5({f/*5*/});
+//// f6({f/*6*/});
+//// f7({f/*7*/});
+//// f8({f/*8*/});
+//// f9({f/*9*/});
+//// f10({f/*10*/});
+//// f11({f/*11*/});
+//// f12({f/*12*/});
+//// f13({f/*13*/});
+//// f14({f/*14*/});
+//// f15({f/*15*/});
+//// f16({f/*16*/});
+//// f17({f/*17*/});
+//// f18({f/*18*/});
+
+verify.completions(
+    { marker: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"], includes: ["foo"]},
+    { marker: ["12", "13", "14", "15"], excludes: ["foo"]},
+    { marker: ["16", "17", "18"], excludes: ["foo"], isNewIdentifierLocation: true},
+);

tests/cases/fourslash/completionPropertyShorthandForObjectLiteral2.ts

@@ -0,0 +1,17 @@
+/// <reference path="fourslash.ts"/>
+
+//// const foo = 1;
+//// const bar = 2;
+
+//// const obj1 = {
+////   foo b/*1*/
+//// };
+
+//// const obj2: any = {
+////   foo b/*2*/
+//// };
+
+verify.completions({
+    marker: test.markers(),
+    includes: ["bar"]
+});

tests/cases/fourslash/completionPropertyShorthandForObjectLiteral3.ts

@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts"/>
+
+//// const foo = 1;
+//// const bar = 2;
+//// const obj = {
+////   foo b/*1*/
+
+verify.completions({
+    marker: ["1"],
+    includes: ["bar"]
+});

tests/cases/fourslash/completionPropertyShorthandForObjectLiteral4.ts

@@ -0,0 +1,11 @@
+/// <reference path="fourslash.ts"/>
+
+//// const foo = 1;
+//// const bar = 2;
+//// const obj: any = {
+////   foo b/*1*/
+
+verify.completions({
+    marker: ["1"],
+    includes: ["bar"]
+});

tests/cases/fourslash/completionsGenericUnconstrained.ts

@@ -10,5 +10,8 @@
 
 verify.completions({
   marker: "",
-  exact: []
+  includes: [{
+    name: "Object",
+    sortText: completion.SortText.GlobalsOrKeywords
+  }]
 });

tests/cases/fourslash/completionsSelfDeclaring2.ts

@@ -9,7 +9,10 @@
 
 verify.completions({
   marker: "1",
-  exact: []
+  includes: [{
+    name: "Object",
+    sortText: completion.SortText.GlobalsOrKeywords
+  }]
 });
 
 verify.completions({

tests/cases/fourslash/globalCompletionListInsideObjectLiterals.ts

@@ -28,7 +28,6 @@
 // 5, 6: Literal member completion after member name with empty member expression.
 const exact = ["p1", "p2", "p3", "p4", ...completion.globalsPlus(["ObjectLiterals"])];
 verify.completions(
-    { marker: ["1"], exact, isNewIdentifierLocation: true },
-    { marker: ["2", "3", "5", "6"], exact },
-    { marker: "4", exact: undefined },
+    { marker: ["1",], exact, isNewIdentifierLocation: true },
+    { marker: ["2", "3", "4", "5", "6"], exact }
 );