Finish updating services layer

weswigham · weswigham · commit f6803c607cb0 · 2017-09-06T13:00:10.000-07:00
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -1522,6 +1522,38 @@ namespace ts {
         return false;
     }
 
+    export function hasType(node: VariableLikeDeclaration) {
+        if (node) {
+            switch (node.kind) {
+                case SyntaxKind.VariableDeclaration:
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.PropertySignature:
+                case SyntaxKind.Parameter:
+                    return node.type !== undefined;
+            }
+        }
+
+        return false;
+    }
+
+    export function canHaveType(node: Declaration): node is
+    | VariableDeclaration
+    | PropertyDeclaration
+    | PropertySignature
+    | ParameterDeclaration {
+    if (node) {
+        switch (node.kind) {
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.Parameter:
+                return true;
+        }
+    }
+
+    return false;
+}
+
     export function canHaveInitializer(node: Declaration): node is
         | VariableDeclaration
         | PropertyAssignment
@@ -2083,7 +2115,7 @@ namespace ts {
         return isPropertyAccessExpression(node) && isESSymbolIdentifier(node.expression);
     }
 
-    export function getPropertyNameForPropertyNameNode(name: DeclarationName): __String {
+    export function getPropertyNameForPropertyNameNode(name: DeclarationName | QualifiedName): __String {
         if (name.kind === SyntaxKind.Identifier) {
             return name.escapedText;
         }
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
@@ -329,9 +329,9 @@ namespace ts.BreakpointResolver {
 
                         // If this is name of property assignment, set breakpoint in the initializer
                         if (node.parent.kind === SyntaxKind.PropertyAssignment &&
-                            (<PropertyDeclaration>node.parent).name === node &&
+                            node.parent.name === node &&
                             !isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.parent)) {
-                            return spanInNode((<PropertyDeclaration>node.parent).initializer);
+                            return spanInNode(node.parent.initializer);
                         }
 
                         // Breakpoint in type assertion goes to its operand
diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -987,7 +987,7 @@ namespace ts.Completions {
                 // through type declaration or inference.
                 // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                 // type of parameter will flow in from the contextual type of the function
-                let canGetType = rootDeclaration.initializer || rootDeclaration.type || rootDeclaration.parent.parent.kind === SyntaxKind.ForOfStatement;
+                let canGetType = hasInitializer(rootDeclaration) || hasType(rootDeclaration) || rootDeclaration.parent.parent.kind === SyntaxKind.ForOfStatement;
                 if (!canGetType && rootDeclaration.kind === SyntaxKind.Parameter) {
                     if (isExpression(rootDeclaration.parent)) {
                         canGetType = !!typeChecker.getContextualType(<Expression>rootDeclaration.parent);
diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
@@ -191,7 +191,7 @@ namespace ts.DocumentHighlights {
         let child: Node = throwStatement;
 
         while (child.parent) {
-            const parent = child.parent;
+            const parent: Node = child.parent;
 
             if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
                 return parent;
@@ -307,7 +307,7 @@ namespace ts.DocumentHighlights {
                     nodes = [...(<ClassDeclaration>declaration).members, declaration];
                 }
                 else {
-                    nodes = (<Block>container).statements;
+                    nodes = container.statements;
                 }
                 break;
             case SyntaxKind.Constructor:
@@ -383,7 +383,7 @@ namespace ts.DocumentHighlights {
 
         return keywords;
 
-        function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
+        function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind.GetAccessor | SyntaxKind.SetAccessor): void {
             const accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
 
             if (accessor) {
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
@@ -1058,7 +1058,7 @@ namespace ts.FindAllReferences.Core {
         const containingTypeReference = getContainingTypeReference(refNode);
         if (containingTypeReference && state.markSeenContainingTypeReference(containingTypeReference)) {
             const parent = containingTypeReference.parent;
-            if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {
+            if (isVariableLike(parent) && canHaveType(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {
                 addReference(parent.initializer);
             }
             else if (isFunctionLike(parent) && parent.type === containingTypeReference && (parent as FunctionLikeDeclaration).body) {
@@ -1647,7 +1647,7 @@ namespace ts.FindAllReferences.Core {
             return false;
         }
         else if (isVariableLike(node)) {
-            if (node.initializer) {
+            if (hasInitializer(node)) {
                 return true;
             }
             else if (node.kind === SyntaxKind.VariableDeclaration) {
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -65,11 +65,11 @@ namespace ts {
         }
 
         public getSourceFile(): SourceFile {
-            return getSourceFileOfNode(this);
+            return getSourceFileOfNode(this as Node);
         }
 
         public getStart(sourceFile?: SourceFileLike, includeJsDocComment?: boolean): number {
-            return getTokenPosOfNode(this, sourceFile, includeJsDocComment);
+            return getTokenPosOfNode(this as Node, sourceFile, includeJsDocComment);
         }
 
         public getFullStart(): number {
@@ -109,7 +109,7 @@ namespace ts {
                 const token = scanner.scan();
                 const textPos = scanner.getTextPos();
                 if (textPos <= end) {
-                    nodes.push(createNode(token, pos, textPos, this));
+                    nodes.push(createNode(token, pos, textPos, this as Node) as Node);
                 }
                 pos = textPos;
                 if (token === SyntaxKind.EndOfFileToken) {
@@ -120,7 +120,7 @@ namespace ts {
         }
 
         private createSyntaxList(nodes: NodeArray<Node>): Node {
-            const list = <NodeObject>createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, this);
+            const list = <NodeObject>createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, this as Node);
             list._children = [];
             let pos = nodes.pos;
 
@@ -134,7 +134,7 @@ namespace ts {
             if (pos < nodes.end) {
                 this.addSyntheticNodes(list._children, pos, nodes.end);
             }
-            return list;
+            return list as Node;
         }
 
         private createChildren(sourceFile?: SourceFileLike) {
@@ -143,7 +143,7 @@ namespace ts {
                 return;
             }
 
-            if (isJSDocCommentContainingNode(this)) {
+            if (isJSDocCommentContainingNode(this as Node)) {
                 /** Don't add trivia for "tokens" since this is in a comment. */
                 const children: Node[] = [];
                 this.forEachChild(child => { children.push(child); });
@@ -176,7 +176,7 @@ namespace ts {
             // For that to work, the jsdoc comments should still be the leading trivia of the first child.
             // Restoring the scanner position ensures that.
             pos = this.pos;
-            forEachChild(this, processNode, processNodes);
+            forEachChild(this as Node, processNode, processNodes);
             if (pos < this.end) {
                 this.addSyntheticNodes(children, pos, this.end);
             }
@@ -223,11 +223,11 @@ namespace ts {
         }
 
         public forEachChild<T>(cbNode: (node: Node) => T, cbNodeArray?: (nodes: NodeArray<Node>) => T): T {
-            return forEachChild(this, cbNode, cbNodeArray);
+            return forEachChild(this as Node, cbNode, cbNodeArray);
         }
     }
 
-    class TokenOrIdentifierObject implements Node {
+    class TokenOrIdentifierObject implements BaseNode {
         public kind: SyntaxKind;
         public pos: number;
         public end: number;
@@ -244,11 +244,11 @@ namespace ts {
         }
 
         public getSourceFile(): SourceFile {
-            return getSourceFileOfNode(this);
+            return getSourceFileOfNode(this as Node);
         }
 
         public getStart(sourceFile?: SourceFileLike, includeJsDocComment?: boolean): number {
-            return getTokenPosOfNode(this, sourceFile, includeJsDocComment);
+            return getTokenPosOfNode(this as Node, sourceFile, includeJsDocComment);
         }
 
         public getFullStart(): number {
@@ -740,8 +740,8 @@ namespace ts {
 
     function getServicesObjectAllocator(): ObjectAllocator {
         return {
-            getNodeConstructor: () => NodeObject,
-            getTokenConstructor: () => TokenObject,
+            getNodeConstructor: () => NodeObject as new (kind: SyntaxKind, pos?: number, end?: number) => Node,
+            getTokenConstructor: () => TokenObject as new (kind: SyntaxKind, pos?: number, end?: number) => Node,
 
             getIdentifierConstructor: () => IdentifierObject,
             getSourceFileConstructor: () => SourceFileObject,
@@ -1595,7 +1595,7 @@ namespace ts {
                     return;
             }
 
-            let nodeForStartPos = node;
+            let nodeForStartPos: Node = node;
             while (true) {
                 if (isRightSideOfPropertyAccess(nodeForStartPos) || isRightSideOfQualifiedName(nodeForStartPos)) {
                     // If on the span is in right side of the the property or qualified name, return the span from the qualified name pos to end of this node
diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts
@@ -154,7 +154,7 @@ namespace ts.SignatureHelp {
             const tagExpression = <TaggedTemplateExpression>templateExpression.parent;
             Debug.assert(templateExpression.kind === SyntaxKind.TemplateExpression);
 
-            const argumentIndex = isInsideTemplateLiteral(<LiteralExpression>node, position) ? 0 : 1;
+            const argumentIndex = 1;
 
             return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile);
         }
@@ -165,7 +165,7 @@ namespace ts.SignatureHelp {
             Debug.assert(templateExpression.kind === SyntaxKind.TemplateExpression);
 
             // If we're just after a template tail, don't show signature help.
-            if (node.kind === SyntaxKind.TemplateTail && !isInsideTemplateLiteral(<LiteralExpression>node, position)) {
+            if (node.kind === SyntaxKind.TemplateTail) {
                 return undefined;
             }
 
diff --git a/src/services/textChanges.ts b/src/services/textChanges.ts
@@ -166,7 +166,7 @@ namespace ts.textChanges {
     /**
      * Checks if 'candidate' argument is a legal separator in the list that contains 'node' as an element
      */
-    function isSeparator(node: Node, candidate: Node): candidate is Token<SyntaxKind.CommaToken | SyntaxKind.SemicolonToken> {
+    function isSeparator(node: Node, candidate: Node): candidate is Token<SyntaxKind.CommaToken> | Token<SyntaxKind.SemicolonToken> {
         return candidate && node.parent && (candidate.kind === SyntaxKind.CommaToken || (candidate.kind === SyntaxKind.SemicolonToken && node.parent.kind === SyntaxKind.ObjectLiteralExpression));
     }
 
@@ -425,7 +425,7 @@ namespace ts.textChanges {
                 const afterStart = after.getStart(sourceFile);
                 const afterStartLinePosition = getLineStartPositionForPosition(afterStart, sourceFile);
 
-                let separator: SyntaxKind.CommaToken | SyntaxKind.SemicolonToken;
+                let separator: Token<SyntaxKind.CommaToken> | Token<SyntaxKind.SemicolonToken>;
                 let multilineList = false;
 
                 // insert element after the last element in the list that has more than one item
@@ -436,12 +436,12 @@ namespace ts.textChanges {
                     // if list has only one element then we'll format is as multiline if node has comment in trailing trivia, or as singleline otherwise
                     // i.e. var x = 1 // this is x
                     //     | new element will be inserted at this position
-                    separator = SyntaxKind.CommaToken;
+                    separator = createToken(SyntaxKind.CommaToken);
                 }
                 else {
                     // element has more than one element, pick separator from the list
                     const tokenBeforeInsertPosition = findPrecedingToken(after.pos, sourceFile);
-                    separator = isSeparator(after, tokenBeforeInsertPosition) ? tokenBeforeInsertPosition.kind : SyntaxKind.CommaToken;
+                    separator = isSeparator(after, tokenBeforeInsertPosition) ? createToken(tokenBeforeInsertPosition.kind) as typeof separator : createToken(SyntaxKind.CommaToken);
                     // determine if list is multiline by checking lines of after element and element that precedes it.
                     const afterMinusOneStartLinePosition = getLineStartPositionForPosition(containingList[index - 1].getStart(sourceFile), sourceFile);
                     multilineList = afterMinusOneStartLinePosition !== afterStartLinePosition;
@@ -456,7 +456,7 @@ namespace ts.textChanges {
                         kind: ChangeKind.ReplaceWithSingleNode,
                         sourceFile,
                         range: { pos: end, end },
-                        node: createToken(separator),
+                        node: separator,
                         options: {}
                     });
                     // use the same indentation as 'after' item
@@ -480,7 +480,7 @@ namespace ts.textChanges {
                         sourceFile,
                         range: { pos: end, end },
                         node: newNode,
-                        options: { prefix: `${tokenToString(separator)} ` }
+                        options: { prefix: `${tokenToString(separator.kind)} ` }
                     });
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -1058,7 +1058,7 @@ namespace ts.FindAllReferences.Core {`
`1058`	`1058`	`const containingTypeReference = getContainingTypeReference(refNode);`
`1059`	`1059`	`if (containingTypeReference && state.markSeenContainingTypeReference(containingTypeReference)) {`
`1060`	`1060`	`const parent = containingTypeReference.parent;`
`1061`		`- if (isVariableLike(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {`
	`1061`	`+ if (isVariableLike(parent) && canHaveType(parent) && parent.type === containingTypeReference && parent.initializer && isImplementationExpression(parent.initializer)) {`
`1062`	`1062`	`addReference(parent.initializer);`
`1063`	`1063`	`}`
`1064`	`1064`	`else if (isFunctionLike(parent) && parent.type === containingTypeReference && (parent as FunctionLikeDeclaration).body) {`
`@@ -1647,7 +1647,7 @@ namespace ts.FindAllReferences.Core {`
`1647`	`1647`	`return false;`
`1648`	`1648`	`}`
`1649`	`1649`	`else if (isVariableLike(node)) {`
`1650`		`- if (node.initializer) {`
	`1650`	`+ if (hasInitializer(node)) {`
`1651`	`1651`	`return true;`
`1652`	`1652`	`}`
`1653`	`1653`	`else if (node.kind === SyntaxKind.VariableDeclaration) {`
Original file line number	Diff line number	Diff line change
`@@ -65,11 +65,11 @@ namespace ts {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public getSourceFile(): SourceFile {`
`68`		`- return getSourceFileOfNode(this);`
	`68`	`+ return getSourceFileOfNode(this as Node);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`public getStart(sourceFile?: SourceFileLike, includeJsDocComment?: boolean): number {`
`72`		`- return getTokenPosOfNode(this, sourceFile, includeJsDocComment);`
	`72`	`+ return getTokenPosOfNode(this as Node, sourceFile, includeJsDocComment);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`public getFullStart(): number {`
`@@ -109,7 +109,7 @@ namespace ts {`
`109`	`109`	`const token = scanner.scan();`
`110`	`110`	`const textPos = scanner.getTextPos();`
`111`	`111`	`if (textPos <= end) {`
`112`		`- nodes.push(createNode(token, pos, textPos, this));`
	`112`	`+ nodes.push(createNode(token, pos, textPos, this as Node) as Node);`
`113`	`113`	`}`
`114`	`114`	`pos = textPos;`
`115`	`115`	`if (token === SyntaxKind.EndOfFileToken) {`
`@@ -120,7 +120,7 @@ namespace ts {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`private createSyntaxList(nodes: NodeArray<Node>): Node {`
`123`		`- const list = <NodeObject>createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, this);`
	`123`	`+ const list = <NodeObject>createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, this as Node);`
`124`	`124`	`list._children = [];`
`125`	`125`	`let pos = nodes.pos;`
`126`	`126`
`@@ -134,7 +134,7 @@ namespace ts {`
`134`	`134`	`if (pos < nodes.end) {`
`135`	`135`	`this.addSyntheticNodes(list._children, pos, nodes.end);`
`136`	`136`	`}`
`137`		`- return list;`
	`137`	`+ return list as Node;`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`private createChildren(sourceFile?: SourceFileLike) {`
`@@ -143,7 +143,7 @@ namespace ts {`
`143`	`143`	`return;`
`144`	`144`	`}`
`145`	`145`
`146`		`- if (isJSDocCommentContainingNode(this)) {`
	`146`	`+ if (isJSDocCommentContainingNode(this as Node)) {`
`147`	`147`	`/** Don't add trivia for "tokens" since this is in a comment. */`
`148`	`148`	`const children: Node[] = [];`
`149`	`149`	`this.forEachChild(child => { children.push(child); });`
`@@ -176,7 +176,7 @@ namespace ts {`
`176`	`176`	`// For that to work, the jsdoc comments should still be the leading trivia of the first child.`
`177`	`177`	`// Restoring the scanner position ensures that.`
`178`	`178`	`pos = this.pos;`
`179`		`- forEachChild(this, processNode, processNodes);`
	`179`	`+ forEachChild(this as Node, processNode, processNodes);`
`180`	`180`	`if (pos < this.end) {`
`181`	`181`	`this.addSyntheticNodes(children, pos, this.end);`
`182`	`182`	`}`
`@@ -223,11 +223,11 @@ namespace ts {`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`public forEachChild<T>(cbNode: (node: Node) => T, cbNodeArray?: (nodes: NodeArray<Node>) => T): T {`
`226`		`- return forEachChild(this, cbNode, cbNodeArray);`
	`226`	`+ return forEachChild(this as Node, cbNode, cbNodeArray);`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
`230`		`- class TokenOrIdentifierObject implements Node {`
	`230`	`+ class TokenOrIdentifierObject implements BaseNode {`
`231`	`231`	`public kind: SyntaxKind;`
`232`	`232`	`public pos: number;`
`233`	`233`	`public end: number;`
`@@ -244,11 +244,11 @@ namespace ts {`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`public getSourceFile(): SourceFile {`
`247`		`- return getSourceFileOfNode(this);`
	`247`	`+ return getSourceFileOfNode(this as Node);`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`public getStart(sourceFile?: SourceFileLike, includeJsDocComment?: boolean): number {`
`251`		`- return getTokenPosOfNode(this, sourceFile, includeJsDocComment);`
	`251`	`+ return getTokenPosOfNode(this as Node, sourceFile, includeJsDocComment);`
`252`	`252`	`}`
`253`	`253`
`254`	`254`	`public getFullStart(): number {`
`@@ -740,8 +740,8 @@ namespace ts {`
`740`	`740`
`741`	`741`	`function getServicesObjectAllocator(): ObjectAllocator {`
`742`	`742`	`return {`
`743`		`- getNodeConstructor: () => NodeObject,`
`744`		`- getTokenConstructor: () => TokenObject,`
	`743`	`+ getNodeConstructor: () => NodeObject as new (kind: SyntaxKind, pos?: number, end?: number) => Node,`
	`744`	`+ getTokenConstructor: () => TokenObject as new (kind: SyntaxKind, pos?: number, end?: number) => Node,`
`745`	`745`
`746`	`746`	`getIdentifierConstructor: () => IdentifierObject,`
`747`	`747`	`getSourceFileConstructor: () => SourceFileObject,`
`@@ -1595,7 +1595,7 @@ namespace ts {`
`1595`	`1595`	`return;`
`1596`	`1596`	`}`
`1597`	`1597`
`1598`		`- let nodeForStartPos = node;`
	`1598`	`+ let nodeForStartPos: Node = node;`
`1599`	`1599`	`while (true) {`
`1600`	`1600`	`if (isRightSideOfPropertyAccess(nodeForStartPos) \|\| isRightSideOfQualifiedName(nodeForStartPos)) {`
`1601`	`1601`	`// If on the span is in right side of the the property or qualified name, return the span from the qualified name pos to end of this node`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ namespace ts.SignatureHelp {`
`154`	`154`	`const tagExpression = <TaggedTemplateExpression>templateExpression.parent;`
`155`	`155`	`Debug.assert(templateExpression.kind === SyntaxKind.TemplateExpression);`
`156`	`156`
`157`		`- const argumentIndex = isInsideTemplateLiteral(<LiteralExpression>node, position) ? 0 : 1;`
	`157`	`+ const argumentIndex = 1;`
`158`	`158`
`159`	`159`	`return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile);`
`160`	`160`	`}`
`@@ -165,7 +165,7 @@ namespace ts.SignatureHelp {`
`165`	`165`	`Debug.assert(templateExpression.kind === SyntaxKind.TemplateExpression);`
`166`	`166`
`167`	`167`	`// If we're just after a template tail, don't show signature help.`
`168`		`- if (node.kind === SyntaxKind.TemplateTail && !isInsideTemplateLiteral(<LiteralExpression>node, position)) {`
	`168`	`+ if (node.kind === SyntaxKind.TemplateTail) {`
`169`	`169`	`return undefined;`
`170`	`170`	`}`
`171`	`171`