maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Simplify TextSpan creation (#21306)

Browse source 
* Simplify TextSpan creation

* Rename 'start' to 'pos' where possible
This commit is contained in:
Andy 2018-02-08 13:51:10 -08:00 committed by GitHub
parent 37f15ccb41
commit 16f3b93ffd
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 82 additions and 91 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
src/harness/fourslash.ts
View file

@ -64,7 +64,7 @@ namespace FourSlash {
export interface Range {
fileName: string;
start: number;
pos: number;
end: number;
marker?: Marker;
}
@ -710,9 +710,9 @@ namespace FourSlash {
if (!range) {
this.raiseError(`goToDefinitionsAndBoundSpan failed - found a TextSpan ${JSON.stringify(defs.textSpan)} when it wasn't expected.`);
}
else if (defs.textSpan.start !== range.start || defs.textSpan.length !== range.end - range.start) {
else if (defs.textSpan.start !== range.pos || defs.textSpan.length !== range.end - range.pos) {
const expected: ts.TextSpan = {
start: range.start, length: range.end - range.start
start: range.pos, length: range.end - range.pos
};
this.raiseError(`goToDefinitionsAndBoundSpan failed - expected to find TextSpan ${JSON.stringify(expected)} but got ${JSON.stringify(defs.textSpan)}`);
}
@ -855,7 +855,7 @@ namespace FourSlash {
if (completion.insertText !== insertText) {
this.raiseError(`Expected completion insert text at index ${index} to be ${insertText}, got ${completion.insertText}`);
}
const convertedReplacementSpan = replacementSpan && textSpanFromRange(replacementSpan);
const convertedReplacementSpan = replacementSpan && ts.createTextSpanFromRange(replacementSpan);
try {
assert.deepEqual(completion.replacementSpan, convertedReplacementSpan);
}
@ -1002,8 +1002,8 @@ namespace FourSlash {
private verifyRange(desc: string, expected: Range, actual: ts.Node) {
const actualStart = actual.getStart();
const actualEnd = actual.getEnd();
if (actualStart !== expected.start || actualEnd !== expected.end) {
this.raiseError(`${desc} should be ${expected.start}-${expected.end}, got ${actualStart}-${actualEnd}`);
if (actualStart !== expected.pos || actualEnd !== expected.end) {
this.raiseError(`${desc} should be ${expected.pos}-${expected.end}, got ${actualStart}-${actualEnd}`);
}
}
@ -1053,7 +1053,7 @@ namespace FourSlash {
if (actualReferences.length > expectedReferences.length) {
// Find the unaccounted-for reference.
for (const actual of actualReferences) {
if (!ts.forEach(expectedReferences, r => r.start === actual.textSpan.start)) {
if (!ts.forEach(expectedReferences, r => r.pos === actual.textSpan.start)) {
this.raiseError(`A reference ${stringify(actual)} is unaccounted for.`);
}
}
@ -1062,13 +1062,13 @@ namespace FourSlash {
}
for (const reference of expectedReferences) {
const { fileName, start, end } = reference;
const { fileName, pos, end } = reference;
if (reference.marker && reference.marker.data) {
const { isWriteAccess, isDefinition } = reference.marker.data as { isWriteAccess?: boolean, isDefinition?: boolean };
this.verifyReferencesWorker(actualReferences, fileName, start, end, isWriteAccess, isDefinition);
this.verifyReferencesWorker(actualReferences, fileName, pos, end, isWriteAccess, isDefinition);
}
else {
this.verifyReferencesWorker(actualReferences, fileName, start, end);
this.verifyReferencesWorker(actualReferences, fileName, pos, end);
}
}
}
@ -1092,14 +1092,14 @@ namespace FourSlash {
references: ts.ReferenceEntry[];
}
const fullExpected = ts.map<FourSlashInterface.ReferenceGroup, ReferenceGroupJson>(parts, ({ definition, ranges }) => ({
definition: typeof definition === "string" ? definition : { ...definition, range: textSpanFromRange(definition.range) },
definition: typeof definition === "string" ? definition : { ...definition, range: ts.createTextSpanFromRange(definition.range) },
references: ranges.map<ts.ReferenceEntry>(r => {
const { isWriteAccess = false, isDefinition = false, isInString } = (r.marker && r.marker.data || {}) as { isWriteAccess?: boolean, isDefinition?: boolean, isInString?: true };
return {
isWriteAccess,
isDefinition,
fileName: r.fileName,
textSpan: textSpanFromRange(r),
textSpan: ts.createTextSpanFromRange(r),
...(isInString ? { isInString: true } : undefined),
};
}),
@ -1280,7 +1280,7 @@ Actual: ${stringify(fullActual)}`);
assert.equal(actualQuickInfoDocumentation, expectedDocumentation || "", this.assertionMessageAtLastKnownMarker("quick info doc"));
}
public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; },
public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: TextSpan,
displayParts: ts.SymbolDisplayPart[],
documentation: ts.SymbolDisplayPart[],
tags: ts.JSDocTagInfo[]
@ -1346,11 +1346,11 @@ Actual: ${stringify(fullActual)}`);
this.raiseError("Rename location count does not match result.\n\nExpected: " + stringify(ranges) + "\n\nActual:" + stringify(references));
}
ranges = ranges.sort((r1, r2) => r1.start - r2.start);
ranges = ranges.sort((r1, r2) => r1.pos - r2.pos);
references = references.sort((r1, r2) => r1.textSpan.start - r2.textSpan.start);
ts.zipWith(references, ranges, (reference, range) => {
if (reference.textSpan.start !== range.start || ts.textSpanEnd(reference.textSpan) !== range.end) {
if (reference.textSpan.start !== range.pos || ts.textSpanEnd(reference.textSpan) !== range.end) {
this.raiseError("Rename location results do not match.\n\nExpected: " + stringify(ranges) + "\n\nActual:" + stringify(references));
}
});
@ -1473,9 +1473,9 @@ Actual: ${stringify(fullActual)}`);
}
const expectedRange = this.getRanges()[0];
if (renameInfo.triggerSpan.start !== expectedRange.start ||
if (renameInfo.triggerSpan.start !== expectedRange.pos ||
ts.textSpanEnd(renameInfo.triggerSpan) !== expectedRange.end) {
this.raiseError("Expected triggerSpan [" + expectedRange.start + "," + expectedRange.end + "). Got [" +
this.raiseError("Expected triggerSpan [" + expectedRange.pos + "," + expectedRange.end + "). Got [" +
renameInfo.triggerSpan.start + "," + ts.textSpanEnd(renameInfo.triggerSpan) + ") instead.");
}
}
@ -1964,7 +1964,7 @@ Actual: ${stringify(fullActual)}`);
for (const range of this.testData.ranges) {
if (range.fileName === fileName) {
range.start = updatePosition(range.start);
range.pos = updatePosition(range.pos);
range.end = updatePosition(range.end);
}
}
@ -1999,9 +1999,9 @@ Actual: ${stringify(fullActual)}`);
this.goToPosition(len);
}
public goToRangeStart({ fileName, start }: Range) {
public goToRangeStart({ fileName, pos }: Range) {
this.openFile(fileName);
this.goToPosition(start);
this.goToPosition(pos);
}
public goToTypeDefinition(definitionIndex: number) {
@ -2088,9 +2088,9 @@ Actual: ${stringify(fullActual)}`);
const delayedErrors: string[] = [];
for (const range of ranges) {
const length = range.end - range.start;
const length = range.end - range.pos;
const matchingImpl = ts.find(implementations, impl =>
range.fileName === impl.fileName && range.start === impl.textSpan.start && length === impl.textSpan.length);
range.fileName === impl.fileName && range.pos === impl.textSpan.start && length === impl.textSpan.length);
if (matchingImpl) {
if (range.marker && range.marker.data) {
const expected = <{ displayParts?: ts.SymbolDisplayPart[], parts: string[], kind?: string }>range.marker.data;
@ -2128,7 +2128,7 @@ Actual: ${stringify(fullActual)}`);
if (unsatisfiedRanges.length) {
error += "\nUnsatisfied ranges:";
for (const range of unsatisfiedRanges) {
error += `\n (${range.start}, ${range.end}) in ${range.fileName}: ${this.rangeText(range)}`;
error += `\n (${range.pos}, ${range.end}) in ${range.fileName}: ${this.rangeText(range)}`;
}
}
@ -2173,8 +2173,8 @@ Actual: ${stringify(fullActual)}`);
return result;
}
private rangeText({ fileName, start, end }: Range): string {
return this.getFileContent(fileName).slice(start, end);
private rangeText({ fileName, pos, end }: Range): string {
return this.getFileContent(fileName).slice(pos, end);
}
public verifyCaretAtMarker(markerName = "") {
@ -2345,7 +2345,7 @@ Actual: ${stringify(fullActual)}`);
this.verifyClassifications(expected, actual, this.activeFile.content);
}
public verifyOutliningSpans(spans: TextSpan[]) {
public verifyOutliningSpans(spans: FourSlash.Range[]) {
const actual = this.languageService.getOutliningSpans(this.activeFile.fileName);
if (actual.length !== spans.length) {
@ -2353,13 +2353,13 @@ Actual: ${stringify(fullActual)}`);
}
ts.zipWith(spans, actual, (expectedSpan, actualSpan, i) => {
if (expectedSpan.start !== actualSpan.textSpan.start || expectedSpan.end !== ts.textSpanEnd(actualSpan.textSpan)) {
this.raiseError(`verifyOutliningSpans failed - span ${(i + 1)} expected: (${expectedSpan.start},${expectedSpan.end}), actual: (${actualSpan.textSpan.start},${ts.textSpanEnd(actualSpan.textSpan)})`);
if (expectedSpan.pos !== actualSpan.textSpan.start || expectedSpan.end !== ts.textSpanEnd(actualSpan.textSpan)) {
this.raiseError(`verifyOutliningSpans failed - span ${(i + 1)} expected: (${expectedSpan.pos},${expectedSpan.end}), actual: (${actualSpan.textSpan.start},${ts.textSpanEnd(actualSpan.textSpan)})`);
}
});
}
public verifyTodoComments(descriptors: string[], spans: TextSpan[]) {
public verifyTodoComments(descriptors: string[], spans: Range[]) {
const actual = this.languageService.getTodoComments(this.activeFile.fileName,
descriptors.map(d => { return { text: d, priority: 0 }; }));
@ -2370,8 +2370,8 @@ Actual: ${stringify(fullActual)}`);
ts.zipWith(spans, actual, (expectedSpan, actualComment, i) => {
const actualCommentSpan = ts.createTextSpan(actualComment.position, actualComment.message.length);
if (expectedSpan.start !== actualCommentSpan.start || expectedSpan.end !== ts.textSpanEnd(actualCommentSpan)) {
this.raiseError(`verifyOutliningSpans failed - span ${(i + 1)} expected: (${expectedSpan.start},${expectedSpan.end}), actual: (${actualCommentSpan.start},${ts.textSpanEnd(actualCommentSpan)})`);
if (expectedSpan.pos !== actualCommentSpan.start || expectedSpan.end !== ts.textSpanEnd(actualCommentSpan)) {
this.raiseError(`verifyOutliningSpans failed - span ${(i + 1)} expected: (${expectedSpan.pos},${expectedSpan.end}), actual: (${actualCommentSpan.start},${ts.textSpanEnd(actualCommentSpan)})`);
}
});
}
@ -2830,7 +2830,7 @@ Actual: ${stringify(fullActual)}`);
this.goToRangeStart(r);
this.verifyOccurrencesAtPositionListCount(ranges.length);
for (const range of ranges) {
this.verifyOccurrencesAtPositionListContains(range.fileName, range.start, range.end, isWriteAccess);
this.verifyOccurrencesAtPositionListContains(range.fileName, range.pos, range.end, isWriteAccess);
}
}
}
@ -2886,8 +2886,8 @@ Actual: ${stringify(fullActual)}`);
}
ts.zipWith(expectedRangesInFile, spansInFile, (expectedRange, span) => {
if (span.textSpan.start !== expectedRange.start || ts.textSpanEnd(span.textSpan) !== expectedRange.end) {
this.raiseError(`verifyDocumentHighlights failed - span does not match, actual: ${stringify(span.textSpan)}, expected: ${expectedRange.start}--${expectedRange.end}`);
if (span.textSpan.start !== expectedRange.pos || ts.textSpanEnd(span.textSpan) !== expectedRange.end) {
this.raiseError(`verifyDocumentHighlights failed - span does not match, actual: ${stringify(span.textSpan)}, expected: ${expectedRange.pos}--${expectedRange.end}`);
}
});
}
@ -2970,7 +2970,7 @@ Actual: ${stringify(fullActual)}`);
throw new Error("Exactly one refactor range is allowed per test.");
}
const applicableRefactors = this.languageService.getApplicableRefactors(this.activeFile.fileName, { pos: ranges[0].start, end: ranges[0].end });
const applicableRefactors = this.languageService.getApplicableRefactors(this.activeFile.fileName, { pos: ranges[0].pos, end: ranges[0].end });
const isAvailable = applicableRefactors && applicableRefactors.length > 0;
if (negative && isAvailable) {
this.raiseError(`verifyApplicableRefactorAvailableForRange failed - expected no refactor but found some.`);
@ -3157,7 +3157,7 @@ Actual: ${stringify(fullActual)}`);
assert.equal(item.isRecommended, options && options.isRecommended, "isRecommended");
assert.equal(item.insertText, options && options.insertText, "insertText");
if (options && options.replacementSpan) { // TODO: GH#21679
assert.deepEqual(item.replacementSpan, options && options.replacementSpan && textSpanFromRange(options.replacementSpan), "replacementSpan");
assert.deepEqual(item.replacementSpan, options && options.replacementSpan && ts.createTextSpanFromRange(options.replacementSpan), "replacementSpan");
}
}
@ -3208,7 +3208,7 @@ Actual: ${stringify(fullActual)}`);
private getTextSpanForRangeAtIndex(index: number): ts.TextSpan {
const ranges = this.getRanges();
if (ranges && ranges.length > index) {
return textSpanFromRange(ranges[index]);
return ts.createTextSpanFromRange(ranges[index]);
}
else {
this.raiseError("Supplied span index: " + index + " does not exist in range list of size: " + (ranges ? 0 : ranges.length));
@ -3238,10 +3238,6 @@ Actual: ${stringify(fullActual)}`);
}
}
function textSpanFromRange(range: FourSlash.Range): ts.TextSpan {
return ts.createTextSpanFromBounds(range.start, range.end);
}
export function runFourSlashTest(basePath: string, testType: FourSlashTestType, fileName: string) {
const content = Harness.IO.readFile(fileName);
runFourSlashTestContent(basePath, testType, content, fileName);
@ -3562,7 +3558,7 @@ ${code}
const range: Range = {
fileName,
start: rangeStart.position,
pos: rangeStart.position,
end: (i - 1) - difference,
marker: rangeStart.marker
};
@ -3682,7 +3678,7 @@ ${code}
}
// put ranges in the correct order
localRanges = localRanges.sort((a, b) => a.start < b.start ? -1 : 1);
localRanges = localRanges.sort((a, b) => a.pos < b.pos ? -1 : 1);
localRanges.forEach((r) => { ranges.push(r); });
return {
@ -3755,7 +3751,7 @@ namespace FourSlashInterface {
}
public spans(): ts.TextSpan[] {
return this.ranges().map(r => ts.createTextSpan(r.start, r.end - r.start));
return this.ranges().map(r => ts.createTextSpan(r.pos, r.end - r.pos));
}
public rangesByText(): ts.Map<FourSlash.Range[]> {
@ -4161,7 +4157,7 @@ namespace FourSlashInterface {
this.state.verifyCurrentNameOrDottedNameSpanText(text);
}
public outliningSpansInCurrentFile(spans: FourSlash.TextSpan[]) {
public outliningSpansInCurrentFile(spans: FourSlash.Range[]) {
this.state.verifyOutliningSpans(spans);
}
@ -4244,7 +4240,7 @@ namespace FourSlashInterface {
}
public occurrencesAtPositionContains(range: FourSlash.Range, isWriteAccess?: boolean) {
this.state.verifyOccurrencesAtPositionListContains(range.fileName, range.start, range.end, isWriteAccess);
this.state.verifyOccurrencesAtPositionListContains(range.fileName, range.pos, range.end, isWriteAccess);
}
public occurrencesAtPositionCount(expectedCount: number) {
@ -4309,7 +4305,7 @@ namespace FourSlashInterface {
this.state.verifyRenameLocations(startRanges, options);
}
public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; },
public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: FourSlash.TextSpan,
displayParts: ts.SymbolDisplayPart[], documentation: ts.SymbolDisplayPart[], tags: ts.JSDocTagInfo[]) {
this.state.verifyQuickInfoDisplayParts(kind, kindModifiers, textSpan, displayParts, documentation, tags);
}

12
src/harness/unittests/extractRanges.ts
View file

@ -9,7 +9,7 @@ namespace ts {
if (!selectionRange) {
throw new Error(`Test ${s} does not specify selection range`);
}
const result = refactor.extractSymbol.getRangeToExtract(file, createTextSpanFromBounds(selectionRange.start, selectionRange.end));
const result = refactor.extractSymbol.getRangeToExtract(file, createTextSpanFromRange(selectionRange));
assert(result.targetRange === undefined, "failure expected");
const sortedErrors = result.errors.map(e => <string>e.messageText).sort();
assert.deepEqual(sortedErrors, expectedErrors.sort(), "unexpected errors");
@ -23,19 +23,19 @@ namespace ts {
if (!selectionRange) {
throw new Error(`Test ${s} does not specify selection range`);
}
const result = refactor.extractSymbol.getRangeToExtract(f, createTextSpanFromBounds(selectionRange.start, selectionRange.end));
const result = refactor.extractSymbol.getRangeToExtract(f, createTextSpanFromRange(selectionRange));
const expectedRange = t.ranges.get("extracted");
if (expectedRange) {
let start: number, end: number;
let pos: number, end: number;
if (ts.isArray(result.targetRange.range)) {
start = result.targetRange.range[0].getStart(f);
pos = result.targetRange.range[0].getStart(f);
end = ts.lastOrUndefined(result.targetRange.range).getEnd();
}
else {
start = result.targetRange.range.getStart(f);
pos = result.targetRange.range.getStart(f);
end = result.targetRange.range.getEnd();
}
assert.equal(start, expectedRange.start, "incorrect start of range");
assert.equal(pos, expectedRange.pos, "incorrect pos of range");
assert.equal(end, expectedRange.end, "incorrect end of range");
}
else {

16
src/harness/unittests/extractTestHelpers.ts
View file

@ -2,13 +2,13 @@
/// <reference path="tsserverProjectSystem.ts" />
namespace ts {
export interface Range {
start: number;
interface Range {
pos: number;
end: number;
name: string;
}
export interface Test {
interface Test {
source: string;
ranges: Map<Range>;
}
@ -34,7 +34,7 @@ namespace ts {
const name = s === e
? source.charCodeAt(saved + 1) === CharacterCodes.hash ? "selection" : "extracted"
: source.substring(s, e);
activeRanges.push({ name, start: text.length, end: undefined });
activeRanges.push({ name, pos: text.length, end: undefined });
lastPos = pos;
continue;
}
@ -123,12 +123,12 @@ namespace ts {
cancellationToken: { throwIfCancellationRequested: noop, isCancellationRequested: returnFalse },
program,
file: sourceFile,
startPosition: selectionRange.start,
startPosition: selectionRange.pos,
endPosition: selectionRange.end,
host: notImplementedHost,
formatContext: formatting.getFormatContext(testFormatOptions),
};
const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));
const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromRange(selectionRange));
assert.equal(rangeToExtract.errors, undefined, rangeToExtract.errors && "Range error: " + rangeToExtract.errors[0].messageText);
const infos = refactor.extractSymbol.getAvailableActions(context);
const actions = find(infos, info => info.description === description.message).actions;
@ -186,12 +186,12 @@ namespace ts {
cancellationToken: { throwIfCancellationRequested: noop, isCancellationRequested: returnFalse },
program,
file: sourceFile,
startPosition: selectionRange.start,
startPosition: selectionRange.pos,
endPosition: selectionRange.end,
host: notImplementedHost,
formatContext: formatting.getFormatContext(testFormatOptions),
};
const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));
const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromRange(selectionRange));
assert.isUndefined(rangeToExtract.errors, rangeToExtract.errors && "Range error: " + rangeToExtract.errors[0].messageText);
const infos = refactor.extractSymbol.getAvailableActions(context);
assert.isUndefined(find(infos, info => info.description === description.message));

7
src/services/goToDefinition.ts
View file

@ -149,10 +149,7 @@ namespace ts.GoToDefinition {
// Check if position is on triple slash reference.
const comment = findReferenceInPosition(sourceFile.referencedFiles, position) || findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
if (comment) {
return {
definitions,
textSpan: createTextSpanFromBounds(comment.pos, comment.end)
};
return { definitions, textSpan: createTextSpanFromRange(comment) };
}
const node = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ true);
@ -258,7 +255,7 @@ namespace ts.GoToDefinition {
return createDefinitionInfo(decl, symbolKind, symbolName, containerName);
}
export function findReferenceInPosition(refs: ReadonlyArray<FileReference>, pos: number): FileReference {
export function findReferenceInPosition(refs: ReadonlyArray<FileReference>, pos: number): FileReference | undefined {
for (const ref of refs) {
if (ref.pos <= pos && pos <= ref.end) {
return ref;

4
src/services/navigationBar.ts
View file

@ -632,9 +632,7 @@ namespace ts.NavigationBar {
}
function getNodeSpan(node: Node): TextSpan {
return node.kind === SyntaxKind.SourceFile
? createTextSpanFromBounds(node.getFullStart(), node.getEnd())
: createTextSpanFromNode(node, curSourceFile);
return node.kind === SyntaxKind.SourceFile ? createTextSpanFromRange(node) : createTextSpanFromNode(node, curSourceFile);
}
function getModifiers(node: ts.Node): string {

2
src/services/textChanges.ts
View file

@ -629,7 +629,7 @@ namespace ts.textChanges {
}
private computeSpan(change: Change, _sourceFile: SourceFile): TextSpan {
return createTextSpanFromBounds(change.range.pos, change.range.end);
return createTextSpanFromRange(change.range);
}
private computeNewText(change: Change, sourceFile: SourceFile): string {

4
tests/cases/fourslash/fourslash.ts
View file

@ -102,7 +102,7 @@ declare namespace FourSlashInterface {
}
interface Range {
fileName: string;
start: number;
pos: number;
end: number;
marker?: Marker;
}
@ -289,7 +289,7 @@ declare namespace FourSlashInterface {
baselineGetEmitOutput(): void;
baselineQuickInfo(): void;
nameOrDottedNameSpanTextIs(text: string): void;
outliningSpansInCurrentFile(spans: TextSpan[]): void;
outliningSpansInCurrentFile(spans: Range[]): void;
todoCommentsInCurrentFile(descriptors: string[]): void;
matchingBracePositionInCurrentFile(bracePosition: number, expectedMatchPosition: number): void;
noMatchingBracePositionInCurrentFile(bracePosition: number): void;

8
tests/cases/fourslash/getMatchingBraces.ts
View file

@ -38,7 +38,7 @@
////}
////const x: Array[|<() => void>|] = [];
test.ranges().forEach((range) => {
verify.matchingBracePositionInCurrentFile(range.start, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.start);
});
for (const range of test.ranges()) {
verify.matchingBracePositionInCurrentFile(range.pos, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.pos);
}

6
tests/cases/fourslash/getMatchingBracesAdjacentBraces.ts
View file

@ -4,6 +4,6 @@
// If there is an adjacent opening and closing brace,
// then only the opening brace should get highlighted.
test.ranges().forEach(range => {
verify.matchingBracePositionInCurrentFile(range.start, range.end - 1);
});
for (const range of test.ranges()) {
verify.matchingBracePositionInCurrentFile(range.pos, range.end - 1);
}

8
tests/cases/fourslash/server/brace01.ts
View file

@ -37,7 +37,7 @@
//// }
////}
test.ranges().forEach((range) => {
verify.matchingBracePositionInCurrentFile(range.start, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.start);
});
for (const range of test.ranges()) {
verify.matchingBracePositionInCurrentFile(range.pos, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.pos);
}

8
tests/cases/fourslash/shims-pp/getBraceMatchingAtPosition.ts
View file

@ -37,7 +37,7 @@
//// }
////}
test.ranges().forEach((range) => {
verify.matchingBracePositionInCurrentFile(range.start, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.start);
});
for (const range of test.ranges()) {
verify.matchingBracePositionInCurrentFile(range.pos, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.pos);
}

8
tests/cases/fourslash/shims/getBraceMatchingAtPosition.ts
View file

@ -37,7 +37,7 @@
//// }
////}
test.ranges().forEach((range) => {
verify.matchingBracePositionInCurrentFile(range.start, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.start);
});
for (const range of test.ranges()) {
verify.matchingBracePositionInCurrentFile(range.pos, range.end - 1);
verify.matchingBracePositionInCurrentFile(range.end - 1, range.pos);
}