delete isfulfilled to pass tests

Author: fuafa

src/harness/fourslash.ts

@@ -844,11 +844,8 @@ namespace FourSlash {
 
             let isSortTextEqual: boolean;
             if (!sortText) {
-                isSortTextEqual = actual.isFulfilled
-                    ? actual.sortText === ts.Completions.SortText.LocationPriorityFulfilled
-                    : actual.kindModifiers === 'optional'
-                    ? actual.sortText === ts.Completions.SortText.LocationPriorityOptional
-                    : actual.sortText === ts.Completions.SortText.LocationPriority
+                isSortTextEqual = [ts.Completions.SortText.LocationPriorityFulfilled, ts.Completions.SortText.LocationPriority].indexOf(actual.sortText as ts.Completions.SortText) !== -1
+                    || (actual.kindModifiers === "optional" && actual.sortText === ts.Completions.SortText.LocationPriorityOptional);
             }
             else {
                 isSortTextEqual = actual.sortText === sortText;

src/services/completions.ts

@@ -244,7 +244,6 @@ namespace ts.Completions {
         propertyAccessToConvert: PropertyAccessExpression | undefined,
         isJsxInitializer: IsJsxInitializer | undefined,
         preferences: UserPreferences,
-        isFulfilled: boolean
     ): CompletionEntry | undefined {
         let insertText: string | undefined;
         let replacementSpan: TextSpan | undefined;
@@ -291,7 +290,6 @@ namespace ts.Completions {
             isRecommended: trueOrUndefined(isRecommendedCompletionMatch(symbol, recommendedCompletion, typeChecker)),
             insertText,
             replacementSpan,
-            isFulfilled
         };
     }
 
@@ -343,17 +341,17 @@ namespace ts.Completions {
             }
 
             let sortText = symbolToSortTextMap && symbolToSortTextMap[getSymbolId(symbol)];
-            let isFulfilled = false;
             if (!sortText) {
-                fulfilledSymbols && fulfilledSymbols.forEach(fulfilledSymbol => {
-                    if (fulfilledSymbol.name === symbol.name) {
-                        sortText = SortText.LocationPriorityFulfilled;
-                        isFulfilled = true;
-                    }
-                });
+                if (fulfilledSymbols && fulfilledSymbols.length > 0) {
+                    fulfilledSymbols.forEach(fulfilledSymbol => {
+                        if (fulfilledSymbol.name === symbol.name) {
+                            sortText = SortText.LocationPriorityFulfilled;
+                        }
+                    });
+                }
             }
             if (!sortText) {
-                sortText = SymbolDisplay.getSymbolModifiers(symbol) === 'optional' ? SortText.LocationPriorityOptional : SortText.LocationPriority;
+                sortText = SymbolDisplay.getSymbolModifiers(symbol) === "optional" ? SortText.LocationPriorityOptional : SortText.LocationPriority;
             }
 
             const entry = createCompletionEntry(
@@ -369,7 +367,6 @@ namespace ts.Completions {
                 propertyAccessToConvert,
                 isJsxInitializer,
                 preferences,
-                isFulfilled
             );
             if (!entry) {
                 continue;
@@ -1519,14 +1516,16 @@ namespace ts.Completions {
             if (typeMembers && typeMembers.length > 0) {
                 // Add filtered items to the completion list
                 symbols = filterObjectMembersList(typeMembers, Debug.assertDefined(existingMembers));
-                existingMembers && existingMembers.forEach(member => {
-                    if (member.kind === SyntaxKind.SpreadAssignment) {
-                        const expression = (<SpreadAssignment>member).expression;
-                        const symbol = typeChecker.getSymbolAtLocation(expression);
-                        const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
-                        fulfilledSymbols = type && (<ObjectType>type).properties;
-                    }
-                });
+                if (existingMembers && existingMembers.length > 0) {
+                    existingMembers.forEach(member => {
+                        if (member.kind === SyntaxKind.SpreadAssignment) {
+                            const expression = (<SpreadAssignment>member).expression;
+                            const symbol = typeChecker.getSymbolAtLocation(expression);
+                            const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
+                            fulfilledSymbols = type && (<ObjectType>type).properties;
+                        }
+                    });
+                }
             }
             return GlobalsSearch.Success;
         }

src/services/types.ts

@@ -919,7 +919,6 @@ namespace ts {
         hasAction?: true;
         source?: string;
         isRecommended?: true;
-        isFulfilled?: boolean;
     }
 
     export interface CompletionEntryDetails {

tests/cases/fourslash/completionsPropertiesPriorities.ts

@@ -21,9 +21,9 @@
 verify.completions({
   marker: ['a'],
   exact: [
-    { name: 'B', isFulfilled: true, kindModifiers: 'optional', sortText: completion.SortText.LocationPriorityFulfilled, kind: 'property' },
-    { name: 'a', isFulfilled: true, sortText: completion.SortText.LocationPriorityFulfilled, kind: 'property' },
-    { name: 'c', isFulfilled: false, kindModifiers: 'optional', sortText: completion.SortText.LocationPriorityOptional, kind: 'property' },
-    { name: 'd', isFulfilled: false, sortText: completion.SortText.LocationPriority, kind: 'property' }
+    { name: 'B', kindModifiers: 'optional', sortText: completion.SortText.LocationPriorityFulfilled, kind: 'property' },
+    { name: 'a', sortText: completion.SortText.LocationPriorityFulfilled, kind: 'property' },
+    { name: 'c', kindModifiers: 'optional', sortText: completion.SortText.LocationPriorityOptional, kind: 'property' },
+    { name: 'd', sortText: completion.SortText.LocationPriority, kind: 'property' }
   ]
 });

tests/cases/fourslash/fourslash.ts

@@ -548,7 +548,6 @@ declare namespace FourSlashInterface {
         readonly kind?: string;
         readonly kindModifiers?: string;
         readonly sortText?: completion.SortText;
-        readonly isFulfilled?: boolean;
 
         // details
         readonly text?: string;