completions: Add assertions that symbols are defined (microsoft#21764)

Andy · web-flow · commit 2a17825428cf · 2018-02-08T10:20:01.000-08:00
* completions: Add assertions that symbols are defined

* Add assertion messages
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -2901,6 +2901,13 @@ namespace ts {
             return value;
         }
 
+        export function assertEachDefined<T, A extends ReadonlyArray<T>>(value: A, message: string): A {
+            for (const v of value) {
+                assertDefined(v, message);
+            }
+            return value;
+        }
+
         export function assertNever(member: never, message?: string, stackCrawlMark?: AnyFunction): never {
             return fail(message || `Illegal value: ${member}`, stackCrawlMark || assertNever);
         }
diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -912,7 +912,7 @@ namespace ts.Completions {
             getTypeScriptMemberSymbols();
         }
         else if (isRightOfOpenTag) {
-            const tagSymbols = typeChecker.getJsxIntrinsicTagNames();
+            const tagSymbols = Debug.assertEachDefined(typeChecker.getJsxIntrinsicTagNames(), "getJsxIntrinsicTagNames() should all be defined");
             if (tryGetGlobalSymbols()) {
                 symbols = tagSymbols.concat(symbols.filter(s => !!(s.flags & (SymbolFlags.Value | SymbolFlags.Alias))));
             }
@@ -923,7 +923,7 @@ namespace ts.Completions {
         }
         else if (isStartingCloseTag) {
             const tagName = (<JsxElement>contextToken.parent.parent).openingElement.tagName;
-            const tagSymbol = typeChecker.getSymbolAtLocation(tagName);
+            const tagSymbol = Debug.assertDefined(typeChecker.getSymbolAtLocation(tagName));
 
             if (!typeChecker.isUnknownSymbol(tagSymbol)) {
                 symbols = [tagSymbol];
@@ -971,7 +971,7 @@ namespace ts.Completions {
 
                     if (symbol.flags & (SymbolFlags.Module | SymbolFlags.Enum)) {
                         // Extract module or enum members
-                        const exportedSymbols = typeChecker.getExportsOfModule(symbol);
+                        const exportedSymbols = Debug.assertEachDefined(typeChecker.getExportsOfModule(symbol), "getExportsOfModule() should all be defined");
                         const isValidValueAccess = (symbol: Symbol) => typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name);
                         const isValidTypeAccess = (symbol: Symbol) => symbolCanBeReferencedAtTypeLocation(symbol);
                         const isValidAccess = isRhsOfImportDeclaration ?
@@ -1111,7 +1111,7 @@ namespace ts.Completions {
 
             const symbolMeanings = SymbolFlags.Type | SymbolFlags.Value | SymbolFlags.Namespace | SymbolFlags.Alias;
 
-            symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings);
+            symbols = Debug.assertEachDefined(typeChecker.getSymbolsInScope(scopeNode, symbolMeanings), "getSymbolsInScope() should all be defined");
 
             // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
             if (options.includeInsertTextCompletions && scopeNode.kind !== SyntaxKind.SourceFile) {
@@ -1452,7 +1452,7 @@ namespace ts.Completions {
 
             if (typeMembers && typeMembers.length > 0) {
                 // Add filtered items to the completion list
-                symbols = filterObjectMembersList(typeMembers, existingMembers);
+                symbols = filterObjectMembersList(typeMembers, Debug.assertDefined(existingMembers));
             }
             return true;
         }
@@ -1926,11 +1926,7 @@ namespace ts.Completions {
                 existingImportsOrExports.set(name.escapedText, true);
             }
 
-            if (existingImportsOrExports.size === 0) {
-                return filter(exportsOfModule, e => e.escapedName !== InternalSymbolName.Default);
-            }
-
-            return filter(exportsOfModule, e => e.escapedName !== InternalSymbolName.Default && !existingImportsOrExports.get(e.escapedName));
+            return exportsOfModule.filter(e => e.escapedName !== InternalSymbolName.Default && !existingImportsOrExports.get(e.escapedName));
         }
 
         /**
@@ -1940,7 +1936,7 @@ namespace ts.Completions {
          *          do not occur at the current position and have not otherwise been typed.
          */
         function filterObjectMembersList(contextualMemberSymbols: Symbol[], existingMembers: ReadonlyArray<Declaration>): Symbol[] {
-            if (!existingMembers || existingMembers.length === 0) {
+            if (existingMembers.length === 0) {
                 return contextualMemberSymbols;
             }
 
@@ -1980,7 +1976,7 @@ namespace ts.Completions {
                 existingMemberNames.set(existingName, true);
             }
 
-            return filter(contextualMemberSymbols, m => !existingMemberNames.get(m.escapedName));
+            return contextualMemberSymbols.filter(m => !existingMemberNames.get(m.escapedName));
         }
 
         /**
@@ -2066,7 +2062,7 @@ namespace ts.Completions {
                 }
             }
 
-            return filter(symbols, a => !seenNames.get(a.escapedName));
+            return symbols.filter(a => !seenNames.get(a.escapedName));
         }
 
         function isCurrentlyEditingNode(node: Node): boolean {
@@ -2248,13 +2244,13 @@ namespace ts.Completions {
      */
     function getPropertiesForCompletion(type: Type, checker: TypeChecker, isForAccess: boolean): Symbol[] {
         if (!(type.flags & TypeFlags.Union)) {
-            return type.getApparentProperties();
+            return Debug.assertEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined");
         }
 
         const { types } = type as UnionType;
         // If we're providing completions for an object literal, skip primitive, array-like, or callable types since those shouldn't be implemented by object literals.
         const filteredTypes = isForAccess ? types : types.filter(memberType =>
             !(memberType.flags & TypeFlags.Primitive || checker.isArrayLikeType(memberType) || typeHasCallOrConstructSignatures(memberType, checker)));
-        return checker.getAllPossiblePropertiesOfTypes(filteredTypes);
+        return Debug.assertEachDefined(checker.getAllPossiblePropertiesOfTypes(filteredTypes), "getAllPossiblePropertiesOfTypes() should all be defined");
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -2901,6 +2901,13 @@ namespace ts {`
`2901`	`2901`	`return value;`
`2902`	`2902`	`}`
`2903`	`2903`
	`2904`	`+ export function assertEachDefined<T, A extends ReadonlyArray<T>>(value: A, message: string): A {`
	`2905`	`+ for (const v of value) {`
	`2906`	`+ assertDefined(v, message);`
	`2907`	`+ }`
	`2908`	`+ return value;`
	`2909`	`+ }`
	`2910`	`+`
`2904`	`2911`	`export function assertNever(member: never, message?: string, stackCrawlMark?: AnyFunction): never {`
`2905`	`2912`	return fail(message \|\| `Illegal value: ${member}`, stackCrawlMark \|\| assertNever);
`2906`	`2913`	`}`
Original file line number	Diff line number	Diff line change
`@@ -912,7 +912,7 @@ namespace ts.Completions {`
`912`	`912`	`getTypeScriptMemberSymbols();`
`913`	`913`	`}`
`914`	`914`	`else if (isRightOfOpenTag) {`
`915`		`- const tagSymbols = typeChecker.getJsxIntrinsicTagNames();`
	`915`	`+ const tagSymbols = Debug.assertEachDefined(typeChecker.getJsxIntrinsicTagNames(), "getJsxIntrinsicTagNames() should all be defined");`
`916`	`916`	`if (tryGetGlobalSymbols()) {`
`917`	`917`	`symbols = tagSymbols.concat(symbols.filter(s => !!(s.flags & (SymbolFlags.Value \| SymbolFlags.Alias))));`
`918`	`918`	`}`
`@@ -923,7 +923,7 @@ namespace ts.Completions {`
`923`	`923`	`}`
`924`	`924`	`else if (isStartingCloseTag) {`
`925`	`925`	`const tagName = (<JsxElement>contextToken.parent.parent).openingElement.tagName;`
`926`		`- const tagSymbol = typeChecker.getSymbolAtLocation(tagName);`
	`926`	`+ const tagSymbol = Debug.assertDefined(typeChecker.getSymbolAtLocation(tagName));`
`927`	`927`
`928`	`928`	`if (!typeChecker.isUnknownSymbol(tagSymbol)) {`
`929`	`929`	`symbols = [tagSymbol];`
`@@ -971,7 +971,7 @@ namespace ts.Completions {`
`971`	`971`
`972`	`972`	`if (symbol.flags & (SymbolFlags.Module \| SymbolFlags.Enum)) {`
`973`	`973`	`// Extract module or enum members`
`974`		`- const exportedSymbols = typeChecker.getExportsOfModule(symbol);`
	`974`	`+ const exportedSymbols = Debug.assertEachDefined(typeChecker.getExportsOfModule(symbol), "getExportsOfModule() should all be defined");`
`975`	`975`	`const isValidValueAccess = (symbol: Symbol) => typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name);`
`976`	`976`	`const isValidTypeAccess = (symbol: Symbol) => symbolCanBeReferencedAtTypeLocation(symbol);`
`977`	`977`	`const isValidAccess = isRhsOfImportDeclaration ?`
`@@ -1111,7 +1111,7 @@ namespace ts.Completions {`
`1111`	`1111`
`1112`	`1112`	`const symbolMeanings = SymbolFlags.Type \| SymbolFlags.Value \| SymbolFlags.Namespace \| SymbolFlags.Alias;`
`1113`	`1113`
`1114`		`- symbols = typeChecker.getSymbolsInScope(scopeNode, symbolMeanings);`
	`1114`	`+ symbols = Debug.assertEachDefined(typeChecker.getSymbolsInScope(scopeNode, symbolMeanings), "getSymbolsInScope() should all be defined");`
`1115`	`1115`
`1116`	`1116`	// Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
`1117`	`1117`	`if (options.includeInsertTextCompletions && scopeNode.kind !== SyntaxKind.SourceFile) {`
`@@ -1452,7 +1452,7 @@ namespace ts.Completions {`
`1452`	`1452`
`1453`	`1453`	`if (typeMembers && typeMembers.length > 0) {`
`1454`	`1454`	`// Add filtered items to the completion list`
`1455`		`- symbols = filterObjectMembersList(typeMembers, existingMembers);`
	`1455`	`+ symbols = filterObjectMembersList(typeMembers, Debug.assertDefined(existingMembers));`
`1456`	`1456`	`}`
`1457`	`1457`	`return true;`
`1458`	`1458`	`}`
`@@ -1926,11 +1926,7 @@ namespace ts.Completions {`
`1926`	`1926`	`existingImportsOrExports.set(name.escapedText, true);`
`1927`	`1927`	`}`
`1928`	`1928`
`1929`		`- if (existingImportsOrExports.size === 0) {`
`1930`		`- return filter(exportsOfModule, e => e.escapedName !== InternalSymbolName.Default);`
`1931`		`- }`
`1932`		`-`
`1933`		`- return filter(exportsOfModule, e => e.escapedName !== InternalSymbolName.Default && !existingImportsOrExports.get(e.escapedName));`
	`1929`	`+ return exportsOfModule.filter(e => e.escapedName !== InternalSymbolName.Default && !existingImportsOrExports.get(e.escapedName));`
`1934`	`1930`	`}`
`1935`	`1931`
`1936`	`1932`	`/**`
`@@ -1940,7 +1936,7 @@ namespace ts.Completions {`
`1940`	`1936`	`* do not occur at the current position and have not otherwise been typed.`
`1941`	`1937`	`*/`
`1942`	`1938`	`function filterObjectMembersList(contextualMemberSymbols: Symbol[], existingMembers: ReadonlyArray<Declaration>): Symbol[] {`
`1943`		`- if (!existingMembers \|\| existingMembers.length === 0) {`
	`1939`	`+ if (existingMembers.length === 0) {`
`1944`	`1940`	`return contextualMemberSymbols;`
`1945`	`1941`	`}`
`1946`	`1942`
`@@ -1980,7 +1976,7 @@ namespace ts.Completions {`
`1980`	`1976`	`existingMemberNames.set(existingName, true);`
`1981`	`1977`	`}`
`1982`	`1978`
`1983`		`- return filter(contextualMemberSymbols, m => !existingMemberNames.get(m.escapedName));`
	`1979`	`+ return contextualMemberSymbols.filter(m => !existingMemberNames.get(m.escapedName));`
`1984`	`1980`	`}`
`1985`	`1981`
`1986`	`1982`	`/**`
`@@ -2066,7 +2062,7 @@ namespace ts.Completions {`
`2066`	`2062`	`}`
`2067`	`2063`	`}`
`2068`	`2064`
`2069`		`- return filter(symbols, a => !seenNames.get(a.escapedName));`
	`2065`	`+ return symbols.filter(a => !seenNames.get(a.escapedName));`
`2070`	`2066`	`}`
`2071`	`2067`
`2072`	`2068`	`function isCurrentlyEditingNode(node: Node): boolean {`
`@@ -2248,13 +2244,13 @@ namespace ts.Completions {`
`2248`	`2244`	`*/`
`2249`	`2245`	`function getPropertiesForCompletion(type: Type, checker: TypeChecker, isForAccess: boolean): Symbol[] {`
`2250`	`2246`	`if (!(type.flags & TypeFlags.Union)) {`
`2251`		`- return type.getApparentProperties();`
	`2247`	`+ return Debug.assertEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined");`
`2252`	`2248`	`}`
`2253`	`2249`
`2254`	`2250`	`const { types } = type as UnionType;`
`2255`	`2251`	`// If we're providing completions for an object literal, skip primitive, array-like, or callable types since those shouldn't be implemented by object literals.`
`2256`	`2252`	`const filteredTypes = isForAccess ? types : types.filter(memberType =>`
`2257`	`2253`	`!(memberType.flags & TypeFlags.Primitive \|\| checker.isArrayLikeType(memberType) \|\| typeHasCallOrConstructSignatures(memberType, checker)));`
`2258`		`- return checker.getAllPossiblePropertiesOfTypes(filteredTypes);`
	`2254`	`+ return Debug.assertEachDefined(checker.getAllPossiblePropertiesOfTypes(filteredTypes), "getAllPossiblePropertiesOfTypes() should all be defined");`
`2259`	`2255`	`}`
`2260`	`2256`	`}`