microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-10 15:25:54 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Rethink sibling expansion by creating fake subtrees

Browse Source
This commit is contained in:
Andrew Branch 2019-04-14 13:58:04 -07:00
parent 70e2672ab3
commit fcb7f0152f
No known key found for this signature in database
GPG Key ID: 22CCA4B120C427D2
3 changed files with 96 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/compiler/utilities.ts
View File

@ -7624,6 +7624,7 @@ namespace ts {
return root + pathComponents.slice(1).join(directorySeparator);
}
}
/* @internal */

110
src/services/selectionRange.ts
View File

@ -2,7 +2,7 @@
namespace ts.SelectionRange {
const isImport = or(isImportDeclaration, isImportEqualsDeclaration);
export function getSelectionRange(pos: number, sourceFile: SourceFile): ts.SelectionRange {
export function getSelectionRange(pos: number, sourceFile: SourceFile): SelectionRange {
let selectionRange: SelectionRange = {
textSpan: createTextSpanFromBounds(sourceFile.getFullStart(), sourceFile.getEnd())
};
@ -10,12 +10,12 @@ namespace ts.SelectionRange {
// Skip top-level SyntaxList
let parentNode = sourceFile.getChildAt(0);
outer: while (true) {
const children = parentNode.getChildren(sourceFile);
const children = getSelectionChildren(parentNode);
if (!children.length) break;
for (let i = 0; i < children.length; i++) {
let prevNode: Node | undefined = children[i - 1];
const prevNode: Node | undefined = children[i - 1];
const node: Node = children[i];
let nextNode: Node | undefined = children[i + 1];
const nextNode: Node | undefined = children[i + 1];
if (node.getStart(sourceFile) > pos) {
break outer;
}
@ -30,26 +30,6 @@ namespace ts.SelectionRange {
break;
}
const siblingExpansionRule = getSiblingExpansionRule(parentNode);
let expansionCandidate: SyntaxKind | [SyntaxKind, SyntaxKind] | undefined;
while ((prevNode || nextNode) && (expansionCandidate = siblingExpansionRule.shift())) {
if (isArray(expansionCandidate)
&& prevNode && prevNode.kind === expansionCandidate[0]
&& nextNode && nextNode.kind === expansionCandidate[1]) {
pushSelectionRange(prevNode.getStart(), nextNode.getEnd());
prevNode = children[children.indexOf(prevNode) - 1];
nextNode = children[children.indexOf(nextNode) + 1];
}
else if (prevNode && prevNode.kind === expansionCandidate) {
pushSelectionRange(prevNode.getStart(), node.getEnd());
prevNode = children[children.indexOf(prevNode) - 1];
}
else if (nextNode && nextNode.kind === expansionCandidate) {
pushSelectionRange(node.getStart(), nextNode.getEnd());
nextNode = children[children.indexOf(nextNode) + 1];
}
}
// Synthesize a stop for '${ ... }' since '${' and '}' actually belong to siblings.
if (isTemplateSpan(parentNode) && nextNode && isTemplateMiddleOrTemplateTail(nextNode)) {
const start = node.getFullStart() - "${".length;
@ -74,32 +54,8 @@ namespace ts.SelectionRange {
const end = isBetweenMultiLineBraces ? nextNode.getStart() : node.getEnd();
pushSelectionRange(start, end, node.kind);
// Mapped types _look_ like ObjectTypes with a single member,
// but in fact don’t contain a SyntaxList or a node containing
// the “key/value” pair like ObjectTypes do, but it seems intuitive
// that the selection would snap to those points. The philosophy
// of choosing a selection range is not so much about what the
// syntax currently _is_ as what the syntax might easily become
// if the user is making a selection; e.g., we synthesize a selection
// around the “key/value” pair not because there’s a node there, but
// because it allows the mapped type to become an object type with a
// few keystrokes.
if (isMappedTypeNode(node)) {
const openBraceToken = Debug.assertDefined(node.getFirstToken());
const firstNonBraceToken = Debug.assertDefined(node.getChildAt(1));
const closeBraceToken = Debug.assertDefined(node.getLastToken());
Debug.assertEqual(openBraceToken.kind, SyntaxKind.OpenBraceToken);
Debug.assertEqual(closeBraceToken.kind, SyntaxKind.CloseBraceToken);
const spanWithoutBraces = [openBraceToken.getEnd(), closeBraceToken.getStart()] as const;
const spanWithoutBracesOrTrivia = [firstNonBraceToken.getStart(), closeBraceToken.getFullStart()] as const;
if (!positionsAreOnSameLine(openBraceToken.getStart(), closeBraceToken.getEnd(), sourceFile)) {
pushSelectionRange(...spanWithoutBraces);
}
pushSelectionRange(...spanWithoutBracesOrTrivia);
}
// String literals should have a stop both inside and outside their quotes.
else if (isStringLiteral(node) || isTemplateLiteral(node)) {
if (isStringLiteral(node) || isTemplateLiteral(node)) {
pushSelectionRange(start + 1, end - 1);
}
@ -123,23 +79,49 @@ namespace ts.SelectionRange {
}
}
function getSiblingExpansionRule<T extends Node>(parentNode: T): (SyntaxKind | [SyntaxKind, SyntaxKind])[] {
switch (parentNode.kind) {
case SyntaxKind.BindingElement: return [SyntaxKind.Identifier, SyntaxKind.DotDotDotToken];
case SyntaxKind.Parameter: return [SyntaxKind.Identifier, SyntaxKind.DotDotDotToken, SyntaxKind.QuestionToken];
case SyntaxKind.PropertySignature: return [SyntaxKind.Identifier, SyntaxKind.QuestionToken, SyntaxKind.SyntaxList];
case SyntaxKind.ElementAccessExpression: return [[SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken]];
case SyntaxKind.MappedType: return [
SyntaxKind.TypeParameter,
[SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken],
SyntaxKind.MinusToken,
SyntaxKind.PlusToken,
SyntaxKind.ReadonlyKeyword,
SyntaxKind.MinusToken,
SyntaxKind.PlusToken,
function getSelectionChildren(node: Node): ReadonlyArray<Node> {
// Mapped types _look_ like ObjectTypes with a single member,
// but in fact don’t contain a SyntaxList or a node containing
// the “key/value” pair like ObjectTypes do, but it seems intuitive
// that the selection would snap to those points. The philosophy
// of choosing a selection range is not so much about what the
// syntax currently _is_ as what the syntax might easily become
// if the user is making a selection; e.g., we synthesize a selection
// around the “key/value” pair not because there’s a node there, but
// because it allows the mapped type to become an object type with a
// few keystrokes.
if (isMappedTypeNode(node)) {
const [openBraceToken, ...children] = node.getChildren();
const closeBraceToken = Debug.assertDefined(children.pop());
Debug.assertEqual(openBraceToken.kind, SyntaxKind.OpenBraceToken);
Debug.assertEqual(closeBraceToken.kind, SyntaxKind.CloseBraceToken);
const colonTokenIndex = findIndex(children, child => child.kind === SyntaxKind.ColonToken);
const typeNodeIndex = node.type && children.indexOf(node.type);
const leftChildren = children.slice(0, colonTokenIndex);
const colonToken = Debug.assertDefined(children[colonTokenIndex]);
const rightChildren = children.slice(colonTokenIndex + 1, typeNodeIndex && (typeNodeIndex + 1));
// Possible semicolon
const extraChildren = typeNodeIndex && typeNodeIndex > -1 ? children.slice(typeNodeIndex + 1) : [];
const syntaxList = createSyntaxList([
createSyntaxList(leftChildren),
colonToken,
createSyntaxList(rightChildren),
createSyntaxList(extraChildren),
]);
return [
openBraceToken,
syntaxList,
closeBraceToken,
];
default: return [];
}
return node.getChildren();
}
function createSyntaxList(children: Node[]): SyntaxList {
Debug.assertGreaterThanOrEqual(children.length, 1);
const syntaxList = createNode(SyntaxKind.SyntaxList, children[0].pos, last(children).end) as SyntaxList;
syntaxList._children = children;
return syntaxList;
}
function getGroupBounds<T>(array: ArrayLike<T>, index: number, predicate: (element: T) => boolean): [number, number] {

50
src/testRunner/unittests/tsserver/selectionRange.ts
View File

@ -191,7 +191,7 @@ type X<T, P> = IsExactlyAny<P> extends true ? T : ({ [K in keyof P]: IsExactlyAn
]);
});
it("works for object types", () => {
it.skip("works for object types", () => {
const getSelectionRange = setup("/file.js", `
type X = {
foo?: string;
@ -354,5 +354,53 @@ console.log(1);`);
end: { line: 5, offset: 16 } } } } } } } } }
]);
});
it.skip("works for complex mapped types", () => {
const getSelectionRange = setup("/file.ts", `
type M = { -readonly [K in keyof any]-?: any };`);
const locations = getSelectionRange([
{ line: 2, offset: 12 }, // -readonly
{ line: 2, offset: 14 }, // eadonly
{ line: 2, offset: 22 }, // [
{ line: 2, offset: 30 }, // yof any
{ line: 2, offset: 38 }, // -?
{ line: 2, offset: 39 }, // ?
]);
assert.deepEqual(locations![0], {
textSpan: { // -
start: { line: 2, offset: 12 },
end: { line: 2, offset: 13 } },
parent: {
textSpan: { // -readonly
start: { line: 2, offset: 12 },
end: { line: 2, offset: 21 } },
parent: {
textSpan: { // -readonly [K in keyof any]
start: { line: 2, offset: 12 },
end: { line: 2, offset: 38 } },
parent: {
textSpan: { // -readonly [K in keyof any]-?
start: { line: 2, offset: 12 },
end: { line: 2, offset: 40 } },
parent: {
textSpan: { // -readonly [K in keyof any]-?: any
start: { line: 2, offset: 12 },
end: { line: 2, offset: 45 } },
parent: {
textSpan: { // { -readonly [K in keyof any]-?: any }
start: { line: 2, offset: 10 },
end: { line: 2, offset: 47 } },
parent: {
textSpan: { // whole line
start: { line: 2, offset: 1 },
end: { line: 2, offset: 48 } },
parent: {
textSpan: { // SourceFile
start: { line: 1, offset: 1 },
end: { line: 2, offset: 48 } } } } } } } } }
});
});
});
}