microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-15 12:51:30 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Change TextChangeRange to be a record type as well.

Browse Source
This commit is contained in:
Cyrus Najmabadi
2014-12-16 18:40:15 -08:00
parent 7f3a73b7c8
commit 9df59c39ee
5 changed files with 39 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/compiler/parser.ts
View File

@@ -705,7 +705,7 @@ module ts {
}
function update(newText: string, textChangeRange: TextChangeRange) {
if (textChangeRange.isUnchanged()) {
if (textChangeRangeIsUnchanged(textChangeRange)) {
// if the text didn't change, then we can just return our current source file as-is.
return sourceFile;
}
@@ -725,7 +725,7 @@ module ts {
// The is the amount the nodes after the edit range need to be adjusted. It can be
// positive (if the edit added characters), negative (if the edit deleted characters)
// or zero (if this was a pure overwrite with nothing added/removed).
var delta = changeRange.newSpan().length - changeRange.span().length;
var delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
// If we added or removed characters during the edit, then we need to go and adjust all
// the nodes after the edit. Those nodes may move forward down (if we inserted chars)
@@ -747,7 +747,7 @@ module ts {
// Also, mark any syntax elements that intersect the changed span. We know, up front,
// that we cannot reuse these elements.
updateTokenPositionsAndMarkElements(<IncrementalNode><Node>sourceFile,
changeRange.span().start, textSpanEnd(changeRange.span()), textSpanEnd(changeRange.newSpan()), delta);
changeRange.span.start, textSpanEnd(changeRange.span), textSpanEnd(textChangeRangeNewSpan(changeRange)), delta);
// Now that we've set up our internal incremental state just proceed and parse the
// source file in the normal fashion. When possible the parser will retrieve and
@@ -936,7 +936,7 @@ module ts {
// that the prior token sees that change.
var maxLookahead = 1;
var start = changeRange.span().start;
var start = changeRange.span.start;
// the first iteration aligns us with the change start. subsequent iteration move us to
// the left by maxLookahead tokens. We only need to do this as long as we're not at the
@@ -948,8 +948,8 @@ module ts {
start = Math.max(0, position - 1);
}
var finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span()));
var finalLength = changeRange.newLength() + (changeRange.span().start - start);
var finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span));
var finalLength = changeRange.newLength + (changeRange.span.start - start);
return createTextChangeRange(finalSpan, finalLength);
}

6
src/compiler/types.ts
View File

@@ -1642,9 +1642,7 @@ module ts {
}
export interface TextChangeRange {
span(): TextSpan;
newLength(): number;
newSpan(): TextSpan;
isUnchanged(): boolean;
span: TextSpan;
newLength: number;
}
}

58
src/compiler/utilities.ts
View File

@@ -841,42 +841,34 @@ module ts {
}
export function createTextSpan(start: number, length: number): TextSpan {
if (start < 0) {
throw new Error("start < 0");
}
if (length < 0) {
throw new Error("length < 0");
}
return { start, length };
}
export function createTextSpanFromBounds(start: number, end: number) {
return createTextSpan(start, end - start);
}
export function textChangeRangeNewSpan(range: TextChangeRange) {
return createTextSpan(range.span.start, range.newLength);
}
var textChangeRangeConstructor = (function () {
function textChangeRangeConstructor(span: TextSpan, newLength: number) {
if (newLength < 0) {
throw new Error("newLength < 0");
}
this._span = span;
this._newLength = newLength;
}
textChangeRangeConstructor.prototype = {
span() {
return this._span;
},
newLength() {
return this._newLength;
},
newSpan() {
return createTextSpan(this.span().start, this.newLength());
},
isUnchanged() {
return textSpanIsEmpty(this.span()) && this.newLength() === 0;
}
};
return textChangeRangeConstructor;
})();
export function textChangeRangeIsUnchanged(range: TextChangeRange) {
return textSpanIsEmpty(range.span) && range.newLength === 0;
}
export function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange {
return new (<any>textChangeRangeConstructor)(span, newLength);
if (newLength < 0) {
throw new Error("newLength < 0");
}
return { span, newLength };
}
export var unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0);
@@ -902,9 +894,9 @@ module ts {
// as it makes things much easier to reason about.
var change0 = changes[0];
var oldStartN = change0.span().start;
var oldEndN = textSpanEnd(change0.span());
var newEndN = oldStartN + change0.newLength();
var oldStartN = change0.span.start;
var oldEndN = textSpanEnd(change0.span);
var newEndN = oldStartN + change0.newLength;
for (var i = 1; i < changes.length; i++) {
var nextChange = changes[i];
@@ -993,9 +985,9 @@ module ts {
var oldEnd1 = oldEndN;
var newEnd1 = newEndN;
var oldStart2 = nextChange.span().start;
var oldEnd2 = textSpanEnd(nextChange.span());
var newEnd2 = oldStart2 + nextChange.newLength();
var oldStart2 = nextChange.span.start;
var oldEnd2 = textSpanEnd(nextChange.span);
var newEnd2 = oldStart2 + nextChange.newLength;
oldStartN = Math.min(oldStart1, oldStart2);
oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));

2
src/harness/harnessLanguageService.ts
View File

@@ -87,7 +87,7 @@ module Harness.LanguageService {
return null;
}
return JSON.stringify({ span: { start: range.span().start, length: range.span().length }, newLength: range.newLength() });
return JSON.stringify({ span: { start: range.span.start, length: range.span.length }, newLength: range.newLength });
}
}

10
src/services/services.ts
View File

@@ -1561,15 +1561,15 @@ module ts {
var oldText = sourceFile.scriptSnapshot;
var newText = scriptSnapshot;
Debug.assert((oldText.getLength() - textChangeRange.span().length + textChangeRange.newLength()) === newText.getLength());
Debug.assert((oldText.getLength() - textChangeRange.span.length + textChangeRange.newLength) === newText.getLength());
if (Debug.shouldAssert(AssertionLevel.VeryAggressive)) {
var oldTextPrefix = oldText.getText(0, textChangeRange.span().start);
var newTextPrefix = newText.getText(0, textChangeRange.span().start);
var oldTextPrefix = oldText.getText(0, textChangeRange.span.start);
var newTextPrefix = newText.getText(0, textChangeRange.span.start);
Debug.assert(oldTextPrefix === newTextPrefix);
var oldTextSuffix = oldText.getText(textSpanEnd(textChangeRange.span()), oldText.getLength());
var newTextSuffix = newText.getText(textSpanEnd(textChangeRange.newSpan()), newText.getLength());
var oldTextSuffix = oldText.getText(textSpanEnd(textChangeRange.span), oldText.getLength());
var newTextSuffix = newText.getText(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.getLength());
Debug.assert(oldTextSuffix === newTextSuffix);
}
}