Skip to content

V
vscode

xxadev / vscode
与 Fork 源项目一致

从无法访问的项目Fork

通知 2
Star 0
Fork 0
V
vscode

体验新版 GitCode，发现更多精彩内容 >>

提交 b6ad037e 编写于 作者: A Alex Dima
浏览文件
操作

Minor clean up in /base/

上级 4976ebd2
隐藏空白更改
内联 并排
Showing with 110 addition and 110 deletion
src/vs/base/common/diff/diff.ts
浏览文件 @ b6ad037e
......@@ -71,7 +71,7 @@ export class MyArray {
* A 64-bit integer that represents the number of elements to copy.
*/
public static Copy(sourceArray:any[], sourceIndex:number, destinationArray:any[], destinationIndex:number, length:number) {
for (var i = 0; i < length; i++) {
for (let i = 0; i < length; i++) {
destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
}
}
......@@ -81,7 +81,7 @@ export class MyArray {
// LcsDiff.cs
//
// An implementation of the difference algorithm described in
// "An O(ND) Difference Algorithm and its Variations" by Eugene W. Myers
// "An O(ND) Difference Algorithm and its letiations" by Eugene W. Myers
//
// Copyright (C) 2008 Microsoft Corporation @minifier_do_not_preserve
//*****************************************************************************
......@@ -89,8 +89,8 @@ export class MyArray {
// Our total memory usage for storing history is (worst-case):
// 2 * [(MaxDifferencesHistory + 1) * (MaxDifferencesHistory + 1) - 1] * sizeof(int)
// 2 * [1448*1448 - 1] * 4 = 16773624 = 16MB
var MaxDifferencesHistory = 1447;
//var MaxDifferencesHistory = 100;
let MaxDifferencesHistory = 1447;
//let MaxDifferencesHistory = 100;
......@@ -199,7 +199,7 @@ class DiffChangeHelper {
/**
* An implementation of the difference algorithm described in
* "An O(ND) Difference Algorithm and its Variations" by Eugene W. Myers
* "An O(ND) Difference Algorithm and its letiations" by Eugene W. Myers
*/
export class LcsDiff {
......@@ -229,20 +229,20 @@ export class LcsDiff {
}
private ComputeUniqueIdentifiers(): void {
var originalSequenceLength = this.OriginalSequence.getLength();
var modifiedSequenceLength = this.ModifiedSequence.getLength();
let originalSequenceLength = this.OriginalSequence.getLength();
let modifiedSequenceLength = this.ModifiedSequence.getLength();
this.m_originalIds = new Array<number>(originalSequenceLength);
this.m_modifiedIds = new Array<number>(modifiedSequenceLength);
// Create a new hash table for unique elements from the original
// sequence.
var hashTable:{[key:string]:number;} = {};
var currentUniqueId = 1;
var i: number;
let hashTable:{[key:string]:number;} = {};
let currentUniqueId = 1;
let i: number;
// Fill up the hash table for unique elements
for (i = 0; i < originalSequenceLength; i++) {
var originalElementHash = this.OriginalSequence.getElementHash(i);
let originalElementHash = this.OriginalSequence.getElementHash(i);
if (!hashTable.hasOwnProperty(originalElementHash)) {
// No entry in the hashtable so this is a new unique element.
// Assign the element a new unique identifier and add it to the
......@@ -256,7 +256,7 @@ export class LcsDiff {
// Now match up modified elements
for (i = 0; i < modifiedSequenceLength; i++) {
var modifiedElementHash = this.ModifiedSequence.getElementHash(i);
let modifiedElementHash = this.ModifiedSequence.getElementHash(i);
if (!hashTable.hasOwnProperty(modifiedElementHash)) {
this.m_modifiedIds[i] = currentUniqueId++;
hashTable[modifiedElementHash] = this.m_modifiedIds[i];
......@@ -280,7 +280,7 @@ export class LcsDiff {
* @returns An array of the differences between the two input sequences.
*/
private _ComputeDiff(originalStart:number, originalEnd:number, modifiedStart:number, modifiedEnd:number): DiffChange[] {
var quitEarlyArr = [ false ];
let quitEarlyArr = [ false ];
return this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);
}
......@@ -306,7 +306,7 @@ export class LcsDiff {
// In the special case where we either have all insertions or all deletions or the sequences are identical
if (originalStart > originalEnd || modifiedStart > modifiedEnd) {
var changes:DiffChange[];
let changes:DiffChange[];
if (modifiedStart <= modifiedEnd) {
Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
......@@ -334,11 +334,11 @@ export class LcsDiff {
}
// This problem can be solved using the Divide-And-Conquer technique.
var midOriginalArr = [0], midModifiedArr = [0];
var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
let midOriginalArr = [0], midModifiedArr = [0];
let result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
var midOriginal = midOriginalArr[0];
var midModified = midModifiedArr[0];
let midOriginal = midOriginalArr[0];
let midModified = midModifiedArr[0];
if (result !== null) {
// Result is not-null when there was enough memory to compute the changes while
......@@ -350,8 +350,8 @@ export class LcsDiff {
// Second Half: (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)
// NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point
var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
var rightChanges: DiffChange[] = [];
let leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
let rightChanges: DiffChange[] = [];
if (!quitEarlyArr[0]) {
rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);
......@@ -378,16 +378,16 @@ export class LcsDiff {
originalIndex:number, originalEnd:number, midOriginalArr:number[],
modifiedIndex:number, modifiedEnd:number, midModifiedArr:number[],
deltaIsEven:boolean, quitEarlyArr:boolean[]): DiffChange[] {
var forwardChanges: DiffChange[] = null, reverseChanges: DiffChange[] = null;
let forwardChanges: DiffChange[] = null, reverseChanges: DiffChange[] = null;
// First, walk backward through the forward diagonals history
var changeHelper = new DiffChangeHelper();
var diagonalMin = diagonalForwardStart;
var diagonalMax = diagonalForwardEnd;
var diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;
var lastOriginalIndex = Number.MIN_VALUE;
var historyIndex = this.m_forwardHistory.length - 1;
var diagonal: number;
let changeHelper = new DiffChangeHelper();
let diagonalMin = diagonalForwardStart;
let diagonalMax = diagonalForwardEnd;
let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;
let lastOriginalIndex = Number.MIN_VALUE;
let historyIndex = this.m_forwardHistory.length - 1;
let diagonal: number;
do {
// Get the diagonal index from the relative diagonal number
......@@ -432,11 +432,11 @@ export class LcsDiff {
// TODO: Calculate a partial from the reverse diagonals.
// For now, just assume everything after the midOriginal/midModified point is a diff
var originalStartPoint = midOriginalArr[0] + 1;
var modifiedStartPoint = midModifiedArr[0] + 1;
let originalStartPoint = midOriginalArr[0] + 1;
let modifiedStartPoint = midModifiedArr[0] + 1;
if (forwardChanges !== null && forwardChanges.length > 0) {
var lastForwardChange = forwardChanges[forwardChanges.length - 1];
let lastForwardChange = forwardChanges[forwardChanges.length - 1];
originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());
modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());
}
......@@ -514,10 +514,10 @@ export class LcsDiff {
* @returns The diff changes, if available, otherwise null
*/
private ComputeRecursionPoint(originalStart:number, originalEnd:number, modifiedStart:number, modifiedEnd:number, midOriginalArr:number[], midModifiedArr:number[], quitEarlyArr:boolean[]) {
var originalIndex:number, modifiedIndex:number;
var diagonalForwardStart = 0, diagonalForwardEnd = 0;
var diagonalReverseStart = 0, diagonalReverseEnd = 0;
var numDifferences:number;
let originalIndex:number, modifiedIndex:number;
let diagonalForwardStart = 0, diagonalForwardEnd = 0;
let diagonalReverseStart = 0, diagonalReverseEnd = 0;
let numDifferences:number;
// To traverse the edit graph and produce the proper LCS, our actual
// start position is just outside the given boundary
......@@ -537,26 +537,26 @@ export class LcsDiff {
// The integer value in the cell represents the originalIndex of the furthest
// reaching point found so far that ends in that diagonal.
// The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.
var maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);
var numDiagonals = maxDifferences + 1;
var forwardPoints:number[] = new Array<number>(numDiagonals);
var reversePoints:number[] = new Array<number>(numDiagonals);
let maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);
let numDiagonals = maxDifferences + 1;
let forwardPoints:number[] = new Array<number>(numDiagonals);
let reversePoints:number[] = new Array<number>(numDiagonals);
// diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)
// diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)
var diagonalForwardBase = (modifiedEnd - modifiedStart);
var diagonalReverseBase = (originalEnd - originalStart);
let diagonalForwardBase = (modifiedEnd - modifiedStart);
let diagonalReverseBase = (originalEnd - originalStart);
// diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
// diagonal number (relative to diagonalForwardBase)
// diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
// diagonal number (relative to diagonalReverseBase)
var diagonalForwardOffset = (originalStart - modifiedStart);
var diagonalReverseOffset = (originalEnd - modifiedEnd);
let diagonalForwardOffset = (originalStart - modifiedStart);
let diagonalReverseOffset = (originalEnd - modifiedEnd);
// delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers
// relative to the start diagonal with diagonal numbers relative to the end diagonal.
// The Even/Oddn-ness of this delta is important for determining when we should check for overlap
var delta = diagonalReverseBase - diagonalForwardBase;
var deltaIsEven = (delta % 2 === 0);
let delta = diagonalReverseBase - diagonalForwardBase;
let deltaIsEven = (delta % 2 === 0);
// Here we set up the start and end points as the furthest points found so far
// in both the forward and reverse directions, respectively
......@@ -575,10 +575,10 @@ export class LcsDiff {
// away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).
// --We extend on even diagonals (relative to the reference diagonal) only when numDifferences
// is even and odd diagonals only when numDifferences is odd.
var diagonal:number, tempOriginalIndex:number;
let diagonal:number, tempOriginalIndex:number;
for (numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {
var furthestOriginalIndex = 0;
var furthestModifiedIndex = 0;
let furthestOriginalIndex = 0;
let furthestModifiedIndex = 0;
// Run the algorithm in the forward direction
diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
......@@ -638,7 +638,7 @@ export class LcsDiff {
}
// Check to see if we should be quitting early, before moving on to the next iteration.
var matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
let matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, this.OriginalSequence, matchLengthOfLongest)) {
// We can't finish, so skip ahead to generating a result from what we have.
......@@ -727,7 +727,7 @@ export class LcsDiff {
if (numDifferences <= MaxDifferencesHistory) {
// We are allocating space for one extra int, which we fill with
// the index of the diagonal base index
var temp:number[] = new Array<number>(diagonalForwardEnd - diagonalForwardStart + 2);
let temp:number[] = new Array<number>(diagonalForwardEnd - diagonalForwardStart + 2);
temp[0] = diagonalForwardBase - diagonalForwardStart + 1;
MyArray.Copy(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);
this.m_forwardHistory.push(temp);
......@@ -761,8 +761,8 @@ export class LcsDiff {
* @returns The concatenated list
*/
private ConcatenateChanges(left:DiffChange[], right:DiffChange[]): DiffChange[] {
var mergedChangeArr:DiffChange[] = [];
var result:DiffChange[] = null;
let mergedChangeArr:DiffChange[] = [];
let result:DiffChange[] = null;
if (left.length === 0 || right.length === 0) {
return (right.length > 0) ? right : left;
......@@ -800,10 +800,10 @@ export class LcsDiff {
if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart)
{
var originalStart = left.originalStart;
var originalLength = left.originalLength;
var modifiedStart = left.modifiedStart;
var modifiedLength = left.modifiedLength;
let originalStart = left.originalStart;
let originalLength = left.originalLength;
let modifiedStart = left.modifiedStart;
let modifiedLength = left.modifiedLength;
if (left.originalStart + left.originalLength >= right.originalStart) {
originalLength = right.originalStart + right.originalLength - left.originalStart;
......@@ -841,15 +841,15 @@ export class LcsDiff {
// diagonalsBelow: The number of diagonals below the reference diagonal
// diagonalsAbove: The number of diagonals above the reference diagonal
var diagonalsBelow = diagonalBaseIndex;
var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
var diffEven = (numDifferences % 2 === 0);
let diagonalsBelow = diagonalBaseIndex;
let diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
let diffEven = (numDifferences % 2 === 0);
if (diagonal < 0) {
var lowerBoundEven = (diagonalsBelow % 2 === 0);
let lowerBoundEven = (diagonalsBelow % 2 === 0);
return (diffEven === lowerBoundEven) ? 0 : 1;
} else {
var upperBoundEven = (diagonalsAbove % 2 === 0);
let upperBoundEven = (diagonalsAbove % 2 === 0);
return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;
}
}
......
src/vs/base/common/diff/diff2.ts
浏览文件 @ b6ad037e
......@@ -86,11 +86,11 @@ export class LcsDiff2 {
this.backwardPrev = [];
this.backwardCurr = [];
for (var i = 0, length = this.x.getLength(); i < length; i++) {
for (let i = 0, length = this.x.getLength(); i < length; i++) {
this.resultX[i] = false;
}
for (i = 0, length = this.y.getLength(); i <= length; i++) {
for (let i = 0, length = this.y.getLength(); i <= length; i++) {
this.resultY[i] = false;
}
......@@ -98,20 +98,20 @@ export class LcsDiff2 {
}
private ComputeUniqueIdentifiers() {
var xLength = this.x.getLength();
var yLength = this.y.getLength();
let xLength = this.x.getLength();
let yLength = this.y.getLength();
this.ids_for_x = new Array<number>(xLength);
this.ids_for_y = new Array<number>(yLength);
// Create a new hash table for unique elements from the original
// sequence.
var hashTable:{[key:string]:number;} = {};
var currentUniqueId = 1;
var i:number;
let hashTable:{[key:string]:number;} = {};
let currentUniqueId = 1;
let i:number;
// Fill up the hash table for unique elements
for (i = 0; i < xLength; i++) {
var xElementHash = this.x.getElementHash(i);
let xElementHash = this.x.getElementHash(i);
if (!hashTable.hasOwnProperty(xElementHash)) {
// No entry in the hashtable so this is a new unique element.
// Assign the element a new unique identifier and add it to the
......@@ -125,7 +125,7 @@ export class LcsDiff2 {
// Now match up modified elements
for (i = 0; i < yLength; i++) {
var yElementHash = this.y.getElementHash(i);
let yElementHash = this.y.getElementHash(i);
if (!hashTable.hasOwnProperty(yElementHash)) {
this.ids_for_y[i] = currentUniqueId++;
hashTable[yElementHash] = this.ids_for_y[i];
......@@ -140,16 +140,16 @@ export class LcsDiff2 {
}
private ComputeDiff(): IDiffChange[] {
var xLength = this.x.getLength();
var yLength = this.y.getLength();
let xLength = this.x.getLength();
let yLength = this.y.getLength();
this.execute(0, xLength - 1, 0, yLength - 1);
// Construct the changes
var i = 0;
var j = 0;
var xChangeStart, yChangeStart;
var changes = [];
let i = 0;
let j = 0;
let xChangeStart, yChangeStart;
let changes = [];
while (i < xLength && j < yLength) {
if (this.resultX[i] && this.resultY[j]) {
// No change
......@@ -177,7 +177,7 @@ export class LcsDiff2 {
}
private forward(xStart:number, xStop:number, yStart:number, yStop:number): number[] {
var prev = this.forwardPrev,
let prev = this.forwardPrev,
curr = this.forwardCurr,
tmp:number[],
i:number,
......@@ -212,7 +212,7 @@ export class LcsDiff2 {
}
private backward(xStart:number, xStop:number, yStart:number, yStop:number): number[] {
var prev = this.backwardPrev,
let prev = this.backwardPrev,
curr = this.backwardCurr,
tmp:number[],
i:number,
......@@ -247,14 +247,14 @@ export class LcsDiff2 {
}
private findCut(xStart:number, xStop:number, yStart:number, yStop:number, middle:number): number {
var L1 = this.forward(xStart, middle, yStart, yStop);
var L2 = this.backward(middle + 1, xStop, yStart, yStop);
let L1 = this.forward(xStart, middle, yStart, yStop);
let L2 = this.backward(middle + 1, xStop, yStart, yStop);
// First cut
var max = L2[yStart], cut = yStart-1;
let max = L2[yStart], cut = yStart-1;
// Middle cut
for (var j = yStart; j < yStop; j++) {
for (let j = yStart; j < yStop; j++) {
if (L1[j] + L2[j+1] > max) {
max = L1[j] + L2[j+1];
cut = j;
......@@ -291,7 +291,7 @@ export class LcsDiff2 {
return;
}
var found:number, i:number;
let found:number, i:number;
if (xStart === xStop) {
found = -1;
for (i = yStart; i <= yStop; i++) {
......@@ -318,8 +318,8 @@ export class LcsDiff2 {
this.resultY[yStart] = true;
}
} else {
var middle = Math.floor((xStart + xStop) / 2);
var cut = this.findCut(xStart, xStop, yStart, yStop, middle);
let middle = Math.floor((xStart + xStop) / 2);
let cut = this.findCut(xStart, xStop, yStart, yStop, middle);
if (yStart <= cut) {
this.execute(xStart, middle, yStart, cut);
......
src/vs/base/common/diff/diffChange.ts
浏览文件 @ b6ad037e
......@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
export var DifferenceType = {
export const DifferenceType = {
Add : 0,
Remove : 1,
Change : 2
......
src/vs/base/common/worker/workerClient.ts
浏览文件 @ b6ad037e
......@@ -4,9 +4,9 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as timer from 'vs/base/common/timer';
import {TPromise} from 'vs/base/common/winjs.base';
import timer = require('vs/base/common/timer');
import errors = require('vs/base/common/errors');
import {onUnexpectedError, transformErrorForSerialization} from 'vs/base/common/errors';
import protocol = require('vs/base/common/worker/workerProtocol');
import remote = require('vs/base/common/remote');
import marshalling = require('vs/base/common/marshalling');
......@@ -69,9 +69,9 @@ export class WorkerClient {
onCrashCallback(this);
});
var loaderConfiguration:any = null;
let loaderConfiguration:any = null;
var globalRequire = (<any>window).require;
let globalRequire = (<any>window).require;
if (typeof globalRequire.getConfig === 'function') {
// Get the configuration from the Monaco AMD Loader
loaderConfiguration = globalRequire.getConfig();
......@@ -80,7 +80,7 @@ export class WorkerClient {
loaderConfiguration = (<any>window).requirejs.s.contexts._.config;
}
var MonacoEnvironment = (<any>window).MonacoEnvironment || null;
let MonacoEnvironment = (<any>window).MonacoEnvironment || null;
this.onModuleLoaded = this._sendMessage(protocol.MessageType.INITIALIZE, {
id: this._worker.getId(),
......@@ -111,7 +111,7 @@ export class WorkerClient {
throw new Error('Illegal requestName: ' + requestName);
}
var shouldCancelPromise = false,
let shouldCancelPromise = false,
messagePromise:TPromise<any>;
return new TPromise<any>((c, e, p) => {
......@@ -139,11 +139,11 @@ export class WorkerClient {
}
public dispose(): void {
var promises = Object.keys(this._promises);
let promises = Object.keys(this._promises);
if (promises.length > 0) {
console.warn('Terminating a worker with ' + promises.length + ' pending promises:');
console.warn(this._promises);
for (var id in this._promises) {
for (let id in this._promises) {
if (promises.hasOwnProperty(id)) {
this._promises[id].error('Worker forcefully terminated');
}
......@@ -162,15 +162,15 @@ export class WorkerClient {
private _sendMessage(type:string, payload:any, forceTimestamp:number=(new Date()).getTime()):TPromise<any> {
var msg = {
let msg = {
id: ++this._lastMessageId,
type: type,
timestamp: forceTimestamp,
payload: payload
};
var pc:(value:any)=>void, pe:(err:any)=>void, pp:(progress:any)=>void;
var promise = new TPromise<any>((c, e, p) => {
let pc:(value:any)=>void, pe:(err:any)=>void, pp:(progress:any)=>void;
let promise = new TPromise<any>((c, e, p) => {
pc = c;
pe = e;
pp = p;
......@@ -194,7 +194,7 @@ export class WorkerClient {
private _enqueueMessage(msg:protocol.IClientMessage): void {
var lastIndexSmallerOrEqual = -1,
let lastIndexSmallerOrEqual = -1,
i:number;
// Find the right index to insert at - keep the queue ordered by timestamp
......@@ -210,7 +210,7 @@ export class WorkerClient {
}
private _removeMessage(msgId:number): void {
for (var i = 0, len = this._messagesQueue.length; i < len; i++) {
for (let i = 0, len = this._messagesQueue.length; i < len; i++) {
if (this._messagesQueue[i].id === msgId) {
if (this._promises.hasOwnProperty(String(msgId))) {
delete this._promises[String(msgId)];
......@@ -236,7 +236,7 @@ export class WorkerClient {
return;
}
var delayUntilNextMessage = this._messagesQueue[0].timestamp - (new Date()).getTime();
let delayUntilNextMessage = this._messagesQueue[0].timestamp - (new Date()).getTime();
delayUntilNextMessage = Math.max(0, delayUntilNextMessage);
this._processQueueTimeout = setTimeout(() => {
......@@ -245,7 +245,7 @@ export class WorkerClient {
return;
}
this._waitingForWorkerReply = true;
var msg = this._messagesQueue.shift();
let msg = this._messagesQueue.shift();
this._lastTimerEvent = timer.start(timer.Topic.WORKER, this._decodeMessageName(msg));
this._postMessage(msg);
}, delayUntilNextMessage);
......@@ -256,7 +256,7 @@ export class WorkerClient {
}
private _onSerializedMessage(msg:string): void {
var message:protocol.IServerMessage = null;
let message:protocol.IServerMessage = null;
try {
message = marshalling.parse(msg);
} catch (e) {
......@@ -277,7 +277,7 @@ export class WorkerClient {
switch (msg.type) {
case protocol.MessageType.REPLY:
var serverReplyMessage = <protocol.IServerReplyMessage>msg;
let serverReplyMessage = <protocol.IServerReplyMessage>msg;
this._waitingForWorkerReply = false;
if(this._lastTimerEvent) {
......@@ -301,7 +301,7 @@ export class WorkerClient {
payload: this._promises[serverReplyMessage.id].payload
});
this._onError('And the worker replied with an error:', serverReplyMessage.payload);
errors.onUnexpectedError(serverReplyMessage.payload);
onUnexpectedError(serverReplyMessage.payload);
this._promises[serverReplyMessage.id].error(serverReplyMessage.payload);
delete this._promises[serverReplyMessage.id];
break;
......@@ -313,7 +313,7 @@ export class WorkerClient {
break;
case protocol.MessageType.PRINT:
var serverPrintMessage = <protocol.IServerPrintMessage>msg;
let serverPrintMessage = <protocol.IServerPrintMessage>msg;
this._consoleLog(serverPrintMessage.level, serverPrintMessage.payload);
break;
......@@ -326,25 +326,25 @@ export class WorkerClient {
private _dispatchRequestFromWorker(msg:protocol.IServerMessage): void {
this._handleWorkerRequest(msg).then((result) => {
var reply: protocol.IClientReplyMessage = {
let reply: protocol.IClientReplyMessage = {
id: 0,
type: protocol.MessageType.REPLY,
timestamp: (new Date()).getTime(),
seq: msg.req,
payload: (result instanceof Error ? errors.transformErrorForSerialization(result) : result),
payload: (result instanceof Error ? transformErrorForSerialization(result) : result),
err: null
};
this._postMessage(reply);
}, (err) => {
var reply: protocol.IClientReplyMessage = {
let reply: protocol.IClientReplyMessage = {
id: 0,
type: protocol.MessageType.REPLY,
timestamp: (new Date()).getTime(),
seq: msg.req,
payload: null,
err: (err instanceof Error ? errors.transformErrorForSerialization(err) : err)
err: (err instanceof Error ? transformErrorForSerialization(err) : err)
};
this._postMessage(reply);
});
......
src/vs/workbench/services/request/node/requestService.ts
浏览文件 @ b6ad037e
......@@ -96,7 +96,7 @@ export class RequestService extends BaseRequestService implements IThreadSynchro
* Make a cross origin request using NodeJS.
* Note: This method is also called from workers.
*/
public makeCrossOriginRequest(options: http.IXHROptions): TPromise<http.IXHRResponse> {
protected makeCrossOriginRequest(options: http.IXHROptions): TPromise<http.IXHRResponse> {
let timerVar: timer.ITimerEvent = timer.nullEvent;
return this.rawHttpServicePromise.then((rawHttpService: IRawHttpService) => {
return async.always(rawHttpService.xhr(options), ((xhr: http.IXHRResponse) => {
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或