Skip to content

Commit b6ad037

Browse files
alexdimaalexdima
committed
Minor clean up in /base/
1 parent 4976ebd commit b6ad037

5 files changed

Lines changed: 110 additions & 110 deletions

File tree

‎src/vs/base/common/diff/diff.ts‎

Lines changed: 61 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ export class MyArray {
7171
* A 64-bit integer that represents the number of elements to copy.
7272
*/
7373
public static Copy(sourceArray:any[], sourceIndex:number, destinationArray:any[], destinationIndex:number, length:number) {
74-
for (var i = 0; i < length; i++) {
74+
for (let i = 0; i < length; i++) {
7575
destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
7676
}
7777
}
@@ -81,16 +81,16 @@ export class MyArray {
8181
// LcsDiff.cs
8282
//
8383
// An implementation of the difference algorithm described in
84-
// "An O(ND) Difference Algorithm and its Variations" by Eugene W. Myers
84+
// "An O(ND) Difference Algorithm and its letiations" by Eugene W. Myers
8585
//
8686
// Copyright (C) 2008 Microsoft Corporation @minifier_do_not_preserve
8787
//*****************************************************************************
8888

8989
// Our total memory usage for storing history is (worst-case):
9090
// 2 * [(MaxDifferencesHistory + 1) * (MaxDifferencesHistory + 1) - 1] * sizeof(int)
9191
// 2 * [1448*1448 - 1] * 4 = 16773624 = 16MB
92-
var MaxDifferencesHistory = 1447;
93-
//var MaxDifferencesHistory = 100;
92+
let MaxDifferencesHistory = 1447;
93+
//let MaxDifferencesHistory = 100;
9494

9595

9696

@@ -199,7 +199,7 @@ class DiffChangeHelper {
199199

200200
/**
201201
* An implementation of the difference algorithm described in
202-
* "An O(ND) Difference Algorithm and its Variations" by Eugene W. Myers
202+
* "An O(ND) Difference Algorithm and its letiations" by Eugene W. Myers
203203
*/
204204
export class LcsDiff {
205205

@@ -229,20 +229,20 @@ export class LcsDiff {
229229
}
230230

231231
private ComputeUniqueIdentifiers(): void {
232-
var originalSequenceLength = this.OriginalSequence.getLength();
233-
var modifiedSequenceLength = this.ModifiedSequence.getLength();
232+
let originalSequenceLength = this.OriginalSequence.getLength();
233+
let modifiedSequenceLength = this.ModifiedSequence.getLength();
234234
this.m_originalIds = new Array<number>(originalSequenceLength);
235235
this.m_modifiedIds = new Array<number>(modifiedSequenceLength);
236236

237237
// Create a new hash table for unique elements from the original
238238
// sequence.
239-
var hashTable:{[key:string]:number;} = {};
240-
var currentUniqueId = 1;
241-
var i: number;
239+
let hashTable:{[key:string]:number;} = {};
240+
let currentUniqueId = 1;
241+
let i: number;
242242

243243
// Fill up the hash table for unique elements
244244
for (i = 0; i < originalSequenceLength; i++) {
245-
var originalElementHash = this.OriginalSequence.getElementHash(i);
245+
let originalElementHash = this.OriginalSequence.getElementHash(i);
246246
if (!hashTable.hasOwnProperty(originalElementHash)) {
247247
// No entry in the hashtable so this is a new unique element.
248248
// Assign the element a new unique identifier and add it to the
@@ -256,7 +256,7 @@ export class LcsDiff {
256256

257257
// Now match up modified elements
258258
for (i = 0; i < modifiedSequenceLength; i++) {
259-
var modifiedElementHash = this.ModifiedSequence.getElementHash(i);
259+
let modifiedElementHash = this.ModifiedSequence.getElementHash(i);
260260
if (!hashTable.hasOwnProperty(modifiedElementHash)) {
261261
this.m_modifiedIds[i] = currentUniqueId++;
262262
hashTable[modifiedElementHash] = this.m_modifiedIds[i];
@@ -280,7 +280,7 @@ export class LcsDiff {
280280
* @returns An array of the differences between the two input sequences.
281281
*/
282282
private _ComputeDiff(originalStart:number, originalEnd:number, modifiedStart:number, modifiedEnd:number): DiffChange[] {
283-
var quitEarlyArr = [ false ];
283+
let quitEarlyArr = [ false ];
284284
return this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);
285285
}
286286

@@ -306,7 +306,7 @@ export class LcsDiff {
306306

307307
// In the special case where we either have all insertions or all deletions or the sequences are identical
308308
if (originalStart > originalEnd || modifiedStart > modifiedEnd) {
309-
var changes:DiffChange[];
309+
let changes:DiffChange[];
310310

311311
if (modifiedStart <= modifiedEnd) {
312312
Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
@@ -334,11 +334,11 @@ export class LcsDiff {
334334
}
335335

336336
// This problem can be solved using the Divide-And-Conquer technique.
337-
var midOriginalArr = [0], midModifiedArr = [0];
338-
var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
337+
let midOriginalArr = [0], midModifiedArr = [0];
338+
let result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
339339

340-
var midOriginal = midOriginalArr[0];
341-
var midModified = midModifiedArr[0];
340+
let midOriginal = midOriginalArr[0];
341+
let midModified = midModifiedArr[0];
342342

343343
if (result !== null) {
344344
// Result is not-null when there was enough memory to compute the changes while
@@ -350,8 +350,8 @@ export class LcsDiff {
350350
// Second Half: (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)
351351
// NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point
352352

353-
var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
354-
var rightChanges: DiffChange[] = [];
353+
let leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
354+
let rightChanges: DiffChange[] = [];
355355

356356
if (!quitEarlyArr[0]) {
357357
rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);
@@ -378,16 +378,16 @@ export class LcsDiff {
378378
originalIndex:number, originalEnd:number, midOriginalArr:number[],
379379
modifiedIndex:number, modifiedEnd:number, midModifiedArr:number[],
380380
deltaIsEven:boolean, quitEarlyArr:boolean[]): DiffChange[] {
381-
var forwardChanges: DiffChange[] = null, reverseChanges: DiffChange[] = null;
381+
let forwardChanges: DiffChange[] = null, reverseChanges: DiffChange[] = null;
382382

383383
// First, walk backward through the forward diagonals history
384-
var changeHelper = new DiffChangeHelper();
385-
var diagonalMin = diagonalForwardStart;
386-
var diagonalMax = diagonalForwardEnd;
387-
var diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;
388-
var lastOriginalIndex = Number.MIN_VALUE;
389-
var historyIndex = this.m_forwardHistory.length - 1;
390-
var diagonal: number;
384+
let changeHelper = new DiffChangeHelper();
385+
let diagonalMin = diagonalForwardStart;
386+
let diagonalMax = diagonalForwardEnd;
387+
let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;
388+
let lastOriginalIndex = Number.MIN_VALUE;
389+
let historyIndex = this.m_forwardHistory.length - 1;
390+
let diagonal: number;
391391

392392
do {
393393
// Get the diagonal index from the relative diagonal number
@@ -432,11 +432,11 @@ export class LcsDiff {
432432
// TODO: Calculate a partial from the reverse diagonals.
433433
// For now, just assume everything after the midOriginal/midModified point is a diff
434434

435-
var originalStartPoint = midOriginalArr[0] + 1;
436-
var modifiedStartPoint = midModifiedArr[0] + 1;
435+
let originalStartPoint = midOriginalArr[0] + 1;
436+
let modifiedStartPoint = midModifiedArr[0] + 1;
437437

438438
if (forwardChanges !== null && forwardChanges.length > 0) {
439-
var lastForwardChange = forwardChanges[forwardChanges.length - 1];
439+
let lastForwardChange = forwardChanges[forwardChanges.length - 1];
440440
originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());
441441
modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());
442442
}
@@ -514,10 +514,10 @@ export class LcsDiff {
514514
* @returns The diff changes, if available, otherwise null
515515
*/
516516
private ComputeRecursionPoint(originalStart:number, originalEnd:number, modifiedStart:number, modifiedEnd:number, midOriginalArr:number[], midModifiedArr:number[], quitEarlyArr:boolean[]) {
517-
var originalIndex:number, modifiedIndex:number;
518-
var diagonalForwardStart = 0, diagonalForwardEnd = 0;
519-
var diagonalReverseStart = 0, diagonalReverseEnd = 0;
520-
var numDifferences:number;
517+
let originalIndex:number, modifiedIndex:number;
518+
let diagonalForwardStart = 0, diagonalForwardEnd = 0;
519+
let diagonalReverseStart = 0, diagonalReverseEnd = 0;
520+
let numDifferences:number;
521521

522522
// To traverse the edit graph and produce the proper LCS, our actual
523523
// start position is just outside the given boundary
@@ -537,26 +537,26 @@ export class LcsDiff {
537537
// The integer value in the cell represents the originalIndex of the furthest
538538
// reaching point found so far that ends in that diagonal.
539539
// The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.
540-
var maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);
541-
var numDiagonals = maxDifferences + 1;
542-
var forwardPoints:number[] = new Array<number>(numDiagonals);
543-
var reversePoints:number[] = new Array<number>(numDiagonals);
540+
let maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);
541+
let numDiagonals = maxDifferences + 1;
542+
let forwardPoints:number[] = new Array<number>(numDiagonals);
543+
let reversePoints:number[] = new Array<number>(numDiagonals);
544544
// diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)
545545
// diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)
546-
var diagonalForwardBase = (modifiedEnd - modifiedStart);
547-
var diagonalReverseBase = (originalEnd - originalStart);
546+
let diagonalForwardBase = (modifiedEnd - modifiedStart);
547+
let diagonalReverseBase = (originalEnd - originalStart);
548548
// diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
549549
// diagonal number (relative to diagonalForwardBase)
550550
// diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
551551
// diagonal number (relative to diagonalReverseBase)
552-
var diagonalForwardOffset = (originalStart - modifiedStart);
553-
var diagonalReverseOffset = (originalEnd - modifiedEnd);
552+
let diagonalForwardOffset = (originalStart - modifiedStart);
553+
let diagonalReverseOffset = (originalEnd - modifiedEnd);
554554

555555
// delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers
556556
// relative to the start diagonal with diagonal numbers relative to the end diagonal.
557557
// The Even/Oddn-ness of this delta is important for determining when we should check for overlap
558-
var delta = diagonalReverseBase - diagonalForwardBase;
559-
var deltaIsEven = (delta % 2 === 0);
558+
let delta = diagonalReverseBase - diagonalForwardBase;
559+
let deltaIsEven = (delta % 2 === 0);
560560

561561
// Here we set up the start and end points as the furthest points found so far
562562
// in both the forward and reverse directions, respectively
@@ -575,10 +575,10 @@ export class LcsDiff {
575575
// away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).
576576
// --We extend on even diagonals (relative to the reference diagonal) only when numDifferences
577577
// is even and odd diagonals only when numDifferences is odd.
578-
var diagonal:number, tempOriginalIndex:number;
578+
let diagonal:number, tempOriginalIndex:number;
579579
for (numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {
580-
var furthestOriginalIndex = 0;
581-
var furthestModifiedIndex = 0;
580+
let furthestOriginalIndex = 0;
581+
let furthestModifiedIndex = 0;
582582

583583
// Run the algorithm in the forward direction
584584
diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
@@ -638,7 +638,7 @@ export class LcsDiff {
638638
}
639639

640640
// Check to see if we should be quitting early, before moving on to the next iteration.
641-
var matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
641+
let matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
642642

643643
if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, this.OriginalSequence, matchLengthOfLongest)) {
644644
// We can't finish, so skip ahead to generating a result from what we have.
@@ -727,7 +727,7 @@ export class LcsDiff {
727727
if (numDifferences <= MaxDifferencesHistory) {
728728
// We are allocating space for one extra int, which we fill with
729729
// the index of the diagonal base index
730-
var temp:number[] = new Array<number>(diagonalForwardEnd - diagonalForwardStart + 2);
730+
let temp:number[] = new Array<number>(diagonalForwardEnd - diagonalForwardStart + 2);
731731
temp[0] = diagonalForwardBase - diagonalForwardStart + 1;
732732
MyArray.Copy(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);
733733
this.m_forwardHistory.push(temp);
@@ -761,8 +761,8 @@ export class LcsDiff {
761761
* @returns The concatenated list
762762
*/
763763
private ConcatenateChanges(left:DiffChange[], right:DiffChange[]): DiffChange[] {
764-
var mergedChangeArr:DiffChange[] = [];
765-
var result:DiffChange[] = null;
764+
let mergedChangeArr:DiffChange[] = [];
765+
let result:DiffChange[] = null;
766766

767767
if (left.length === 0 || right.length === 0) {
768768
return (right.length > 0) ? right : left;
@@ -800,10 +800,10 @@ export class LcsDiff {
800800

801801
if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart)
802802
{
803-
var originalStart = left.originalStart;
804-
var originalLength = left.originalLength;
805-
var modifiedStart = left.modifiedStart;
806-
var modifiedLength = left.modifiedLength;
803+
let originalStart = left.originalStart;
804+
let originalLength = left.originalLength;
805+
let modifiedStart = left.modifiedStart;
806+
let modifiedLength = left.modifiedLength;
807807

808808
if (left.originalStart + left.originalLength >= right.originalStart) {
809809
originalLength = right.originalStart + right.originalLength - left.originalStart;
@@ -841,15 +841,15 @@ export class LcsDiff {
841841

842842
// diagonalsBelow: The number of diagonals below the reference diagonal
843843
// diagonalsAbove: The number of diagonals above the reference diagonal
844-
var diagonalsBelow = diagonalBaseIndex;
845-
var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
846-
var diffEven = (numDifferences % 2 === 0);
844+
let diagonalsBelow = diagonalBaseIndex;
845+
let diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
846+
let diffEven = (numDifferences % 2 === 0);
847847

848848
if (diagonal < 0) {
849-
var lowerBoundEven = (diagonalsBelow % 2 === 0);
849+
let lowerBoundEven = (diagonalsBelow % 2 === 0);
850850
return (diffEven === lowerBoundEven) ? 0 : 1;
851851
} else {
852-
var upperBoundEven = (diagonalsAbove % 2 === 0);
852+
let upperBoundEven = (diagonalsAbove % 2 === 0);
853853
return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;
854854
}
855855
}

0 commit comments

Comments
 (0)