Update return types of APIs (microsoft#15887)

ajafff · mhegazy · commit 5fb77a09011f · 2017-05-16T14:13:58.000-07:00
* Update types.ts

* Update types in parser.ts and scanner.ts
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -23,19 +23,19 @@ namespace ts {
         }
     }
 
-    function visitNode<T>(cbNode: (node: Node) => T, node: Node): T {
+    function visitNode<T>(cbNode: (node: Node) => T, node: Node): T | undefined {
         if (node) {
             return cbNode(node);
         }
     }
 
-    function visitNodeArray<T>(cbNodes: (nodes: Node[]) => T, nodes: Node[]) {
+    function visitNodeArray<T>(cbNodes: (nodes: Node[]) => T, nodes: Node[]): T | undefined {
         if (nodes) {
             return cbNodes(nodes);
         }
     }
 
-    function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]) {
+    function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]): T | undefined {
         if (nodes) {
             for (const node of nodes) {
                 const result = cbNode(node);
@@ -50,7 +50,7 @@ namespace ts {
     // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
     // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
     // a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
-    export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T {
+    export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T | undefined {
         if (!node) {
             return;
         }
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
@@ -712,11 +712,11 @@ namespace ts {
         return accumulator;
     }
 
-    export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
+    export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U | undefined {
         return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ false, cb, state);
     }
 
-    export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
+    export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U | undefined {
         return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ true, cb, state);
     }
 
@@ -746,10 +746,11 @@ namespace ts {
     }
 
     /** Optionally, get the shebang */
-    export function getShebang(text: string): string {
-        return shebangTriviaRegex.test(text)
-            ? shebangTriviaRegex.exec(text)[0]
-            : undefined;
+    export function getShebang(text: string): string | undefined {
+        const match = shebangTriviaRegex.exec(text);
+        if (match) {
+            return match[0];
+        }
     }
 
     export function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2527,11 +2527,11 @@ namespace ts {
         indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, kind: IndexKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): IndexSignatureDeclaration;
 
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
-        getSymbolAtLocation(node: Node): Symbol;
+        getSymbolAtLocation(node: Node): Symbol | undefined;
         getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
-        getShorthandAssignmentValueSymbol(location: Node): Symbol;
-        getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol;
-        getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol;
+        getShorthandAssignmentValueSymbol(location: Node): Symbol | undefined;
+        getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol | undefined;
+        getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol | undefined;
         getTypeAtLocation(node: Node): Type;
         getTypeFromTypeNode(node: TypeNode): Type;
         signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
@@ -2542,15 +2542,15 @@ namespace ts {
         getAugmentedPropertiesOfType(type: Type): Symbol[];
         getRootSymbols(symbol: Symbol): Symbol[];
         getContextualType(node: Expression): Type | undefined;
-        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;
-        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
-        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
+        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature | undefined;
+        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined;
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean | undefined;
         isUndefinedSymbol(symbol: Symbol): boolean;
         isArgumentsSymbol(symbol: Symbol): boolean;
         isUnknownSymbol(symbol: Symbol): boolean;
         /* @internal */ getMergedSymbol(symbol: Symbol): Symbol;
 
-        getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
+        getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number | undefined;
         isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
         /** Follow all aliases to get the original symbol. */
         getAliasedSymbol(symbol: Symbol): Symbol;
@@ -2560,18 +2560,18 @@ namespace ts {
         /** Unlike `getExportsOfModule`, this includes properties of an `export =` value. */
         /* @internal */ getExportsAndPropertiesOfModule(moduleSymbol: Symbol): Symbol[];
 
-        getAllAttributesTypeFromJsxOpeningLikeElement(elementNode: JsxOpeningLikeElement): Type;
+        getAllAttributesTypeFromJsxOpeningLikeElement(elementNode: JsxOpeningLikeElement): Type | undefined;
         getJsxIntrinsicTagNames(): Symbol[];
         isOptionalParameter(node: ParameterDeclaration): boolean;
         getAmbientModules(): Symbol[];
 
         tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
         getApparentType(type: Type): Type;
         getSuggestionForNonexistentProperty(node: Identifier, containingType: Type): string | undefined;
-        getSuggestionForNonexistentSymbol(location: Node, name: string, meaning: SymbolFlags): string;
-        /* @internal */ getBaseConstraintOfType(type: Type): Type;
+        getSuggestionForNonexistentSymbol(location: Node, name: string, meaning: SymbolFlags): string | undefined;
+        /* @internal */ getBaseConstraintOfType(type: Type): Type | undefined;
 
-        /* @internal */ tryFindAmbientModuleWithoutAugmentations(moduleName: string): Symbol;
+        /* @internal */ tryFindAmbientModuleWithoutAugmentations(moduleName: string): Symbol | undefined;
 
         // Should not be called directly.  Should only be accessed through the Program instance.
         /* @internal */ getDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
@@ -2753,7 +2753,7 @@ namespace ts {
         getNodeCheckFlags(node: Node): NodeCheckFlags;
         isDeclarationVisible(node: Declaration): boolean;
         collectLinkedAliases(node: Identifier): Node[];
-        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean | undefined;
         isRequiredInitializedParameter(node: ParameterDeclaration): boolean;
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
@@ -3135,7 +3135,7 @@ namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;    // Type reference target
-        typeArguments: Type[];  // Type reference type arguments (undefined if none)
+        typeArguments?: Type[];  // Type reference type arguments (undefined if none)
     }
 
     // Generic class and interface types
@@ -3265,7 +3265,7 @@ namespace ts {
 
     export interface Signature {
         declaration: SignatureDeclaration;  // Originating declaration
-        typeParameters: TypeParameter[];    // Type parameters (undefined if non-generic)
+        typeParameters?: TypeParameter[];    // Type parameters (undefined if non-generic)
         parameters: Symbol[];               // Parameters
         /* @internal */
         thisParameter?: Symbol;             // symbol of this-type parameter

Original file line number	Diff line number	Diff line change
`@@ -23,19 +23,19 @@ namespace ts {`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`		`- function visitNode<T>(cbNode: (node: Node) => T, node: Node): T {`
	`26`	`+ function visitNode<T>(cbNode: (node: Node) => T, node: Node): T \| undefined {`
`27`	`27`	`if (node) {`
`28`	`28`	`return cbNode(node);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`- function visitNodeArray<T>(cbNodes: (nodes: Node[]) => T, nodes: Node[]) {`
	`32`	`+ function visitNodeArray<T>(cbNodes: (nodes: Node[]) => T, nodes: Node[]): T \| undefined {`
`33`	`33`	`if (nodes) {`
`34`	`34`	`return cbNodes(nodes);`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`38`		`- function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]) {`
	`38`	`+ function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]): T \| undefined {`
`39`	`39`	`if (nodes) {`
`40`	`40`	`for (const node of nodes) {`
`41`	`41`	`const result = cbNode(node);`
`@@ -50,7 +50,7 @@ namespace ts {`
`50`	`50`	`// stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,`
`51`	`51`	`// embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns`
`52`	`52`	`// a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.`
`53`		`- export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T {`
	`53`	`+ export function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T \| undefined {`
`54`	`54`	`if (!node) {`
`55`	`55`	`return;`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -712,11 +712,11 @@ namespace ts {`
`712`	`712`	`return accumulator;`
`713`	`713`	`}`
`714`	`714`
`715`		`- export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {`
	`715`	`+ export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U \| undefined {`
`716`	`716`	`return iterateCommentRanges(/reduce/ false, text, pos, /trailing/ false, cb, state);`
`717`	`717`	`}`
`718`	`718`
`719`		`- export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {`
	`719`	`+ export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U \| undefined {`
`720`	`720`	`return iterateCommentRanges(/reduce/ false, text, pos, /trailing/ true, cb, state);`
`721`	`721`	`}`
`722`	`722`
`@@ -746,10 +746,11 @@ namespace ts {`
`746`	`746`	`}`
`747`	`747`
`748`	`748`	`/** Optionally, get the shebang */`
`749`		`- export function getShebang(text: string): string {`
`750`		`- return shebangTriviaRegex.test(text)`
`751`		`- ? shebangTriviaRegex.exec(text)[0]`
`752`		`- : undefined;`
	`749`	`+ export function getShebang(text: string): string \| undefined {`
	`750`	`+ const match = shebangTriviaRegex.exec(text);`
	`751`	`+ if (match) {`
	`752`	`+ return match[0];`
	`753`	`+ }`
`753`	`754`	`}`
`754`	`755`
`755`	`756`	`export function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean {`