8000 Compute consistent argument indices and counts for signature help. · creatio/TypeScript@d9d90b2 · GitHub
[go: up one dir, main page]
Skip to content

Commit d9d90b2

Browse files
CyrusNajmabadiCyrusNajmabadi
committed
Compute consistent argument indices and counts for signature help.
1 parent 42ae38d commit d9d90b2

File tree

3 files changed

+47
-20
lines changed

3 files changed

+47
-20
lines changed

‎src/services/services.ts

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -207,6 +207,10 @@ module ts {
207207
if (pos < nodes.end) {
208208
this.addSyntheticNodes(list._children, pos, nodes.end);
209209
}
210+
211+
if (nodes.hasTrailingComma) {
212+
213+
}
210214
return list;
211215
}
212216

‎src/services/signatureHelp.ts

Lines changed: 41 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -238,7 +238,7 @@ module ts.SignatureHelp {
238238
invocation: callExpression,
239239
argumentsSpan: getApplicableSpanForArguments(list),
240240
argumentIndex: 0,
241-
argumentCount: getCommaBasedArgCount(list)
241+
argumentCount: getArgumentCount(list)
242242
};
243243
}
244244

@@ -253,20 +253,11 @@ module ts.SignatureHelp {
253253
var list = listItemInfo.list;
254254
var isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos;
255255

256-
// The listItemIndex we got back includes commas. Our goal is to return the index of the proper
257-
// item (not including commas). Here are some examples:
258-
// 1. foo(a, b, c #) -> the listItemIndex is 4, we want to return 2
259-
// 2. foo(a, b, # c) -> listItemIndex is 3, we want to return 2
260-
// 3. foo(#a) -> listItemIndex is 0, we want to return 0
261-
//
262-
// In general, we want to subtract the number of commas before the current index.
263-
// But if we are on a comma, we also want to pretend we are on the argument *following*
264-
// the comma. That amounts to taking the ceiling of half the index.
265-
var argumentIndex = (listItemInfo.listItemIndex + 1) >> 1;
256+
var argumentIndex = getArgumentIndex(list, node);
257+
var argumentCount = getArgumentCount(list);
266258

267-
var argumentCount = getCommaBasedArgCount(list);
268-
269-
Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount, `argumentCount < argumentIndex, ${argumentCount} < ${argumentIndex}`);
259+
Debug.assert(argumentIndex === 0 || argumentIndex < argumentCount,
260+
`argumentCount < argumentIndex, ${argumentCount} < ${argumentIndex}`);
270261

271262
return {
272263
kind: isTypeArgList ? ArgumentListKind.TypeArguments : ArgumentListKind.CallArguments,
@@ -313,12 +304,42 @@ module ts.SignatureHelp {
313304
return undefined;
314305
}
315306

316-
function getCommaBasedArgCount(argumentsList: Node) {
317-
// The number of arguments is the number of commas plus one, unless the list
318-
// is completely empty, in which case there are 0 arguments.
319-
return argumentsList.getChildCount() === 0
320-
? 0
321-
: 1 + countWhere(argumentsList.getChildren(), arg => arg.kind === SyntaxKind.CommaToken);
307+
function getArgumentIndex(argumentsList: Node, node: Node) {
308+
// The list we got back can include commas. In the presence of errors it may
309+
// also just have nodes without commas. For example "Foo(a b c)" will have 3
310+
// args without commas. We want to find what index we're at. So we count
311+
// forward until we hit ourselves, only incrementing the index if it isn't a
312+
// comma.
313+
var argumentIndex = 0;
314+
var listChildren = argumentsList.getChildren();
315+
for (var i = 0, n = listChildren.length; i < n; i++) {
316+
var child = listChildren[i];
317+
if (child === node) {
318+
break;
319+
}
320+
if (child.kind !== SyntaxKind.CommaToken) {
321+
argumentIndex++;
322+
}
323+
}
324+
325+
return argumentIndex;
326+
}
327+
328+
function getArgumentCount(argumentsList: Node) {
329+
// The argument count for a list is normally the number of non-comma children it has.
330+
// For example, if you have "Foo(a,b)" then there will be three children of the arg
331+
// list 'a' '<comma>' 'b'. So, in this case the arg count will be 2. However, there
332+
// is a small subtlety. If you have "Foo(a,)", then the child list will just have
333+
// 'a' '<comma>'. So, in the case where the last child is a comma, we increase the
334+
// arg count by one to compensate.
335+
var listChildren = argumentsList.getChildren();
336+
337+
var argumentCount = countWhere(listChildren, arg => arg.kind !== SyntaxKind.CommaToken);
338+
if (listChildren.length > 0 && lastOrUndefined(listChildren).kind === SyntaxKind.CommaToken) {
339+
argumentCount++;
340+
}
341+
342+
return argumentCount;
322343
}
323344

324345
// spanIndex is either the index for a given template span.

‎src/services/utilities.ts

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,6 +95,8 @@ module ts {
9595
}
9696
});
9797

98+
// Either we didn't find an appropriate list, or the list must contain us.
99+
Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node));
98100
return syntaxList;
99101
}
100102

0 commit comments

Comments
 (0)
0