mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-02-06 02:33:53 -06:00
707 lines
31 KiB
TypeScript
707 lines
31 KiB
TypeScript
/// <reference path='..\..\src\Services\es5compat.ts' />
|
|
|
|
///<reference path='..\..\src\compiler\syntax\references.ts' />
|
|
///<reference path='..\..\src\compiler\syntax\emitter.ts' />
|
|
///<reference path='..\..\src\compiler\syntax\prettyPrinter.ts' />
|
|
///<reference path='Test262.ts' />
|
|
///<reference path='incremental\IncrementalParserTests.ts' />
|
|
///<reference path='..\..\src\compiler\core\environment.ts' />
|
|
///<reference path='..\..\src\harness\diff.ts' />
|
|
///<reference path='..\..\src\compiler\syntaxTreeToAstVisitor.ts' />
|
|
|
|
var timer = new TypeScript.Timer();
|
|
|
|
var specificFile: string =
|
|
// "ExportAssignment5.ts";
|
|
undefined;
|
|
|
|
var generate = false;
|
|
|
|
var htmlReport = new Diff.HtmlBaselineReport("fidelity-report.html");
|
|
htmlReport.reset();
|
|
|
|
class Program {
|
|
runAllTests(verify: boolean): void {
|
|
TypeScript.Environment.standardOut.WriteLine("");
|
|
|
|
if (generate) {
|
|
TypeScript.Environment.standardOut.WriteLine("!!!!!!!!!! WARNING - GENERATING !!!!!!!!!");
|
|
TypeScript.Environment.standardOut.WriteLine("");
|
|
}
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine("Testing against fuzz.");
|
|
// this.runTests("C:\\temp\\fuzz",
|
|
// fileName => this.runParser(fileName, LanguageVersion.EcmaScript5, /*verify:*/ false, /*generateBaselines:*/ generate), 2000);
|
|
|
|
if (true) {
|
|
// return;
|
|
}
|
|
|
|
//TypeScript.Environment.standardOut.WriteLine("Testing Monoco.");
|
|
//this.runTests(TypeScript.Environment.currentDirectory() + "c:\\temp\\monoco",
|
|
// fileName => this.runParser(fileName, TypeScript.LanguageVersion.EcmaScript5, false, /*generateBaselines:*/ generate, /*allowErrors:*/ false));
|
|
|
|
if (specificFile === undefined) {
|
|
TypeScript.Environment.standardOut.WriteLine("Testing Incremental 2.");
|
|
TypeScript.IncrementalParserTests.runAllTests();
|
|
}
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing scanner ES3.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\scanner\\ecmascript3",
|
|
fileName => this.runScanner(fileName, TypeScript.LanguageVersion.EcmaScript3, verify, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing scanner ES5.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\scanner\\ecmascript5",
|
|
fileName => this.runScanner(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing parser ES5.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\parser\\ecmascript5",
|
|
fileName => this.runParser(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing parser ES3.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\parser\\ecmascript3",
|
|
fileName => this.runParser(fileName, TypeScript.LanguageVersion.EcmaScript3, verify, /*generateBaselines:*/ generate));
|
|
|
|
if (specificFile === undefined) {
|
|
this.testIncrementalSpeed(TypeScript.Environment.currentDirectory() + "\\src\\compiler\\Syntax\\SyntaxNodes.generated.ts");
|
|
}
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing emitter 1.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\emitter\\ecmascript5",
|
|
fileName => this.runEmitter(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate, /*justText:*/ false));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing against 262.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\test262",
|
|
fileName => this.runParser(fileName, TypeScript.LanguageVersion.EcmaScript5, /*verify:*/ true, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing pretty printer.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\prettyPrinter\\ecmascript5",
|
|
fileName => this.runPrettyPrinter(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing findToken.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\findToken\\ecmascript5",
|
|
fileName => this.runFindToken(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing trivia.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\trivia\\ecmascript5",
|
|
fileName => this.runTrivia(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing Incremental 1.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\parser\\ecmascript5",
|
|
fileName => this.runIncremental(fileName, TypeScript.LanguageVersion.EcmaScript5));
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Testing emitter 2.");
|
|
this.runTests(TypeScript.Environment.currentDirectory() + "\\tests\\Fidelity\\emitter2\\ecmascript5",
|
|
fileName => this.runEmitter(fileName, TypeScript.LanguageVersion.EcmaScript5, verify, /*generateBaselines:*/ generate, /*justText:*/ true));
|
|
}
|
|
|
|
private static reusedElements(oldNode: TypeScript.SourceUnitSyntax, newNode: TypeScript.SourceUnitSyntax, key: any): { originalElements: number; reusedElements: number; } {
|
|
var allOldElements = TypeScript.SyntaxElementsCollector.collectElements(oldNode);
|
|
var allNewElements = TypeScript.SyntaxElementsCollector.collectElements(newNode);
|
|
|
|
for (var i = 0; i < allOldElements.length; i++) {
|
|
var oldElement: TypeScript.IIndexable<any> = <any>allOldElements[i];
|
|
oldElement[key] = key;
|
|
}
|
|
|
|
var reused = 0;
|
|
for (var j = 0; j < allNewElements.length; j++) {
|
|
var newElement: TypeScript.IIndexable<any> = <any>allNewElements[j];
|
|
if (newElement[key] === key) {
|
|
reused++;
|
|
}
|
|
}
|
|
|
|
return { originalElements: allOldElements.length, reusedElements: reused };
|
|
}
|
|
|
|
private testIncrementalSpeed(fileName: string): void {
|
|
var repeat = 500;
|
|
TypeScript.Environment.standardOut.WriteLine("Incremental Perf - Changed Text.");
|
|
this.testIncrementalSpeedChange(fileName, repeat);
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("");
|
|
TypeScript.Environment.standardOut.WriteLine("Incremental Perf - No Changed Text.");
|
|
this.testIncrementalSpeedNoChange(fileName, repeat);
|
|
}
|
|
|
|
private testIncrementalSpeedNoChange(fileName: string, repeat: number): void {
|
|
if (specificFile !== undefined) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
var tree = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(TypeScript.LanguageVersion.EcmaScript5, true));
|
|
var originalTree = tree;
|
|
var ast = TypeScript.SyntaxTreeToAstVisitor.visit(tree, fileName, TypeScript.ImmutableCompilationSettings.defaultSettings(), /*incrementalAST:*/ true);
|
|
|
|
var totalIncrementalTime = 0;
|
|
var totalIncrementalASTTime = 0;
|
|
var timer = new TypeScript.Timer();
|
|
|
|
for (var i = 0; i < repeat; i++) {
|
|
var changeLength = i * 2;
|
|
|
|
timer.start();
|
|
var tree2 = TypeScript.Parser.incrementalParse(tree, new TypeScript.TextChangeRange( new TypeScript.TextSpan((text.length() / 2) - i, changeLength), changeLength), text);
|
|
timer.end();
|
|
totalIncrementalTime += timer.time;
|
|
|
|
TypeScript.Debug.assert(tree.structuralEquals(tree2));
|
|
|
|
timer.start();
|
|
var ast2 = TypeScript.SyntaxTreeToAstVisitor.visit(tree2, fileName, TypeScript.ImmutableCompilationSettings.defaultSettings(), /*incrementalAST:*/ true);
|
|
timer.end();
|
|
totalIncrementalASTTime += timer.time;
|
|
|
|
TypeScript.Debug.assert(ast.structuralEquals(ast2, true));
|
|
|
|
tree = tree2;
|
|
ast = ast2;
|
|
}
|
|
|
|
var rateBytesPerMillisecond = (contents.length * repeat) / totalIncrementalTime;
|
|
var rateBytesPerSecond = rateBytesPerMillisecond * 1000;
|
|
var rateMBPerSecond = rateBytesPerSecond / (1024 * 1024);
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine("Incremental time: " + totalIncrementalTime);
|
|
TypeScript.Environment.standardOut.WriteLine("Incremental rate: " + rateMBPerSecond + " MB/s");
|
|
|
|
rateBytesPerMillisecond = (contents.length * repeat) / totalIncrementalASTTime;
|
|
rateBytesPerSecond = rateBytesPerMillisecond * 1000;
|
|
rateMBPerSecond = rateBytesPerSecond / (1024 * 1024);
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine("Incremental AST time: " + totalIncrementalASTTime);
|
|
TypeScript.Environment.standardOut.WriteLine("Incremental AST rate: " + rateMBPerSecond + " MB/s");
|
|
|
|
var allOldElements = TypeScript.SyntaxElementsCollector.collectElements(originalTree.sourceUnit());
|
|
var allNewElements = TypeScript.SyntaxElementsCollector.collectElements(tree.sourceUnit());
|
|
|
|
var reuse = TypeScript.ArrayUtilities.where(allNewElements,
|
|
v => TypeScript.ArrayUtilities.contains(allOldElements, v)).length;
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Reuse: " + reuse / allNewElements.length);
|
|
}
|
|
|
|
private testIncrementalSpeedChange(fileName: string, repeat: number): void {
|
|
if (specificFile !== undefined) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
var tree = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(TypeScript.LanguageVersion.EcmaScript5, true));
|
|
var originalTree = tree;
|
|
var ast = TypeScript.SyntaxTreeToAstVisitor.visit(tree, fileName, TypeScript.ImmutableCompilationSettings.defaultSettings(), /*incrementalAST:*/ true);
|
|
|
|
var totalIncrementalTime = 0;
|
|
var totalIncrementalASTTime = 0;
|
|
var timer = new TypeScript.Timer();
|
|
|
|
for (var i = 0; i < repeat; i++) {
|
|
|
|
var changeLength = i * 2;
|
|
var changeSpan = new TypeScript.TextSpan((text.length() / 2) - i, changeLength);
|
|
|
|
contents = text.toString();
|
|
var contentsToReplace = contents.substr(changeSpan.start(), changeSpan.length());
|
|
|
|
var first = true;
|
|
var updatedText = contentsToReplace.replace(/[^a-zA-Z0-9][a-z]+[^a-zA-Z0-9]/, (sub) => {
|
|
if (first && TypeScript.SyntaxFacts.getTokenKind(sub.substr(1, sub.length - 2)) === TypeScript.SyntaxKind.None) {
|
|
first = false;
|
|
return sub.substr(0, sub.length - 1) + "a" + sub.substr(sub.length - 1);
|
|
}
|
|
|
|
return sub;
|
|
});
|
|
|
|
text = TypeScript.TextFactory.createText(
|
|
contents.substr(0, changeSpan.start()) +
|
|
updatedText +
|
|
contents.substr(changeSpan.end()));
|
|
var changeRange = new TypeScript.TextChangeRange(changeSpan, updatedText.length);
|
|
|
|
timer.start();
|
|
var tree2 = TypeScript.Parser.incrementalParse(tree, changeRange, text);
|
|
timer.end();
|
|
totalIncrementalTime += timer.time;
|
|
|
|
timer.start();
|
|
var ast2 = TypeScript.SyntaxTreeToAstVisitor.visit(tree2, fileName, TypeScript.ImmutableCompilationSettings.defaultSettings(), /*incrementalAST:*/ true);
|
|
timer.end();
|
|
totalIncrementalASTTime += timer.time;
|
|
|
|
tree = tree2;
|
|
ast = ast2;
|
|
}
|
|
|
|
var rateBytesPerMillisecond = (contents.length * repeat) / totalIncrementalTime;
|
|
var rateBytesPerSecond = rateBytesPerMillisecond * 1000;
|
|
var rateMBPerSecond = rateBytesPerSecond / (1024 * 1024);
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine("Incremental time: " + totalIncrementalTime);
|
|
TypeScript.Environment.standardOut.WriteLine("Incremental rate: " + rateMBPerSecond + " MB/s");
|
|
|
|
rateBytesPerMillisecond = (contents.length * repeat) / totalIncrementalASTTime;
|
|
rateBytesPerSecond = rateBytesPerMillisecond * 1000;
|
|
rateMBPerSecond = rateBytesPerSecond / (1024 * 1024);
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine("Incremental AST time: " + totalIncrementalASTTime);
|
|
TypeScript.Environment.standardOut.WriteLine("Incremental AST rate: " + rateMBPerSecond + " MB/s");
|
|
|
|
var allOldElements = TypeScript.SyntaxElementsCollector.collectElements(originalTree.sourceUnit());
|
|
var allNewElements = TypeScript.SyntaxElementsCollector.collectElements(tree.sourceUnit());
|
|
|
|
var reuse = TypeScript.ArrayUtilities.where(allNewElements,
|
|
v => TypeScript.ArrayUtilities.contains(allOldElements, v)).length;
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Reuse: " + reuse / allNewElements.length);
|
|
}
|
|
|
|
private handleException(fileName: string, e: Error): void {
|
|
TypeScript.Environment.standardOut.WriteLine("");
|
|
if ((<string>e.message).indexOf(fileName) < 0) {
|
|
TypeScript.Environment.standardOut.WriteLine("Exception: " + fileName + ": " + e.message);
|
|
}
|
|
else {
|
|
TypeScript.Environment.standardOut.WriteLine(e.message);
|
|
}
|
|
}
|
|
|
|
private runTests(
|
|
path: string,
|
|
action: (fileName: string) => void) {
|
|
|
|
var testFiles = TypeScript.Environment.listFiles(path, null, { recursive: true });
|
|
var indexNum = 0;
|
|
|
|
testFiles.forEach(fileName => {
|
|
if (specificFile !== undefined && fileName.indexOf(specificFile) < 0) {
|
|
return;
|
|
}
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
try {
|
|
action(fileName);
|
|
}
|
|
catch (e) {
|
|
this.handleException(fileName, e);
|
|
}
|
|
});
|
|
}
|
|
|
|
private checkResult(fileName: string, result: any, verify: boolean, generateBaseline: boolean, justText: boolean): void {
|
|
var actualResult: string;
|
|
|
|
var expectedFile = fileName + ".expected";
|
|
var actualFile = fileName + ".actual";
|
|
|
|
if (generateBaseline) {
|
|
actualResult = justText ? result : JSON.stringify(result, null, 4);
|
|
expectedFile = fileName + ".expected";
|
|
|
|
// TypeScript.Environment.standardOut.WriteLine("Generating baseline for: " + fileName);
|
|
TypeScript.Environment.writeFile(expectedFile, actualResult, /*writeByteOrderMark:*/ false);
|
|
|
|
if (TypeScript.Environment.fileExists(actualFile)) {
|
|
TypeScript.Environment.deleteFile(actualFile);
|
|
}
|
|
}
|
|
else if (verify) {
|
|
actualResult = justText ? result : JSON.stringify(result, null, 4);
|
|
|
|
var expectedResult: string = null;
|
|
if (!TypeScript.Environment.fileExists(expectedFile)) {
|
|
TypeScript.Environment.writeFile(expectedFile, "", false);
|
|
}
|
|
else {
|
|
expectedResult = TypeScript.Environment.readFile(expectedFile, /*codepage*/ null).contents;
|
|
}
|
|
|
|
if (expectedResult !== actualResult) {
|
|
TypeScript.Environment.standardOut.WriteLine(" ! Fail: " + actualFile);
|
|
TypeScript.Environment.writeFile(actualFile, actualResult, /*writeByteOrderMark:*/ false);
|
|
|
|
if (!generate) {
|
|
var includeUnchangedRegions = expectedResult.length < 10240 && actualResult.length < 10240;
|
|
htmlReport.addDifference("", expectedFile, actualFile, expectedResult, actualResult, includeUnchangedRegions);
|
|
}
|
|
}
|
|
else {
|
|
if (TypeScript.Environment.fileExists(actualFile)) {
|
|
TypeScript.Environment.deleteFile(actualFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
runEmitter(fileName: string,
|
|
languageVersion: TypeScript.LanguageVersion,
|
|
verify: boolean,
|
|
generateBaseline: boolean,
|
|
justText: boolean): void {
|
|
if (true) {
|
|
// return;
|
|
}
|
|
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts") && !TypeScript.StringUtilities.endsWith(fileName, ".js")) {
|
|
return;
|
|
}
|
|
|
|
if (fileName.indexOf("RealSource") >= 0) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
totalSize += contents.length;
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
|
|
var tree = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(languageVersion, true));
|
|
var emitted = TypeScript.Emitter1.emit(<TypeScript.SourceUnitSyntax>tree.sourceUnit());
|
|
|
|
var result = justText
|
|
? <any>emitted.fullText()
|
|
: { fullText: emitted.fullText().split("\r\n"), sourceUnit: emitted };
|
|
this.checkResult(fileName, result, verify, generateBaseline, justText);
|
|
}
|
|
|
|
runPrettyPrinter(fileName: string,
|
|
languageVersion: TypeScript.LanguageVersion,
|
|
verify: boolean,
|
|
generateBaseline: boolean): void {
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts") && !TypeScript.StringUtilities.endsWith(fileName, ".js")) {
|
|
return;
|
|
}
|
|
|
|
if (fileName.indexOf("RealSource") >= 0) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
totalSize += contents.length;
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
|
|
var tree = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(languageVersion, true));
|
|
var result = TypeScript.PrettyPrinter.prettyPrint(tree.sourceUnit());
|
|
|
|
this.checkResult(fileName, result, verify, generateBaseline, true);
|
|
|
|
totalTime += timer.time;
|
|
}
|
|
|
|
runParser(fileName: string,
|
|
languageVersion: TypeScript.LanguageVersion,
|
|
verify: boolean,
|
|
generateBaseline: boolean,
|
|
allowErrors = true): void {
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts") && !TypeScript.StringUtilities.endsWith(fileName, ".js")) {
|
|
return;
|
|
}
|
|
|
|
if (fileName.indexOf("RealSource") >= 0) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
totalSize += contents.length;
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
|
|
timer.start();
|
|
var tree = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(languageVersion, true));
|
|
timer.end();
|
|
|
|
if (!allowErrors) {
|
|
var diagnostics = tree.diagnostics();
|
|
if (diagnostics.length > 0) {
|
|
TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
TypeScript.Environment.standardOut.WriteLine("\t" + diagnostics[0].message());
|
|
}
|
|
}
|
|
|
|
if (verify) {
|
|
TypeScript.Debug.assert(tree.sourceUnit().fullWidth() === contents.length);
|
|
|
|
TypeScript.SyntaxTreeToAstVisitor.visit(tree, "", TypeScript.ImmutableCompilationSettings.defaultSettings(), /*incrementalAST:*/ true);
|
|
|
|
this.checkResult(fileName, tree, verify, generateBaseline, /*justText:*/ false);
|
|
}
|
|
totalTime += timer.time;
|
|
}
|
|
|
|
runIncremental(fileName: string,
|
|
languageVersion: TypeScript.LanguageVersion): void {
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts") && !TypeScript.StringUtilities.endsWith(fileName, ".js")) {
|
|
return;
|
|
}
|
|
|
|
if (fileName.indexOf("RealSource") >= 0) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
|
|
var tree1 = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(languageVersion, true));
|
|
var tree2 = TypeScript.Parser.incrementalParse(
|
|
new TypeScript.SyntaxTree(TypeScript.Syntax.emptySourceUnit(), TypeScript.isDTSFile(fileName), [], fileName, null, tree1.parseOptions()),
|
|
new TypeScript.TextChangeRange(new TypeScript.TextSpan(0, 0), text.length()),
|
|
text);
|
|
|
|
TypeScript.Debug.assert(tree1.structuralEquals(tree2));
|
|
}
|
|
|
|
runFindToken(fileName: string,
|
|
languageVersion: TypeScript.LanguageVersion, verify: boolean, generateBaseline: boolean): void {
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts") && !TypeScript.StringUtilities.endsWith(fileName, ".js")) {
|
|
return;
|
|
}
|
|
|
|
if (fileName.indexOf("RealSource") >= 0) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
// TypeScript.Environment.standardOut.WriteLine(fileName);
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
var tree = TypeScript.Parser.parse(fileName, text, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(languageVersion, true));
|
|
var sourceUnit = tree.sourceUnit();
|
|
|
|
TypeScript.Debug.assert(tree.sourceUnit().fullWidth() === contents.length);
|
|
|
|
var tokens: TypeScript.IIndexable<any>= {};
|
|
var tokensOnLeft: TypeScript.IIndexable<any> = {};
|
|
var leftToRight: TypeScript.ISyntaxToken[] = [];
|
|
var rightToLeft: TypeScript.ISyntaxToken[] = [];
|
|
|
|
for (var i = 0; i <= contents.length; i++) {
|
|
var token = sourceUnit.findToken(i).token();
|
|
|
|
var left = sourceUnit.findTokenOnLeft(i);
|
|
var tokenOnLeft = left === null ? null : left.token();
|
|
|
|
TypeScript.Debug.assert(token.isToken());
|
|
if (i === contents.length) {
|
|
TypeScript.Debug.assert(token.kind() === TypeScript.SyntaxKind.EndOfFileToken);
|
|
}
|
|
else {
|
|
TypeScript.Debug.assert(token.width() > 0 || token.kind() === TypeScript.SyntaxKind.EndOfFileToken);
|
|
TypeScript.Debug.assert(token.fullWidth() > 0);
|
|
}
|
|
|
|
tokens[i] = token;
|
|
tokensOnLeft[i] = tokenOnLeft;
|
|
}
|
|
|
|
var positionedToken = sourceUnit.findToken(0);
|
|
while (positionedToken !== null) {
|
|
leftToRight.push(positionedToken.token());
|
|
positionedToken = positionedToken.nextToken();
|
|
}
|
|
|
|
positionedToken = sourceUnit.findToken(contents.length);
|
|
while (positionedToken !== null) {
|
|
rightToLeft.push(positionedToken.token());
|
|
positionedToken = positionedToken.previousToken();
|
|
}
|
|
|
|
var result = {
|
|
tokens: tokens,
|
|
tokensOnLeft: tokensOnLeft,
|
|
leftToRight: leftToRight,
|
|
rightToLeft: rightToLeft,
|
|
};
|
|
|
|
this.checkResult(fileName, result, verify, generateBaseline, /*justText:*/ false);
|
|
}
|
|
|
|
runTrivia(fileName: string,
|
|
languageVersion: TypeScript.LanguageVersion, verify: boolean, generateBaseline: boolean): void {
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts")) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
var scanner = new TypeScript.Scanner(fileName, text, languageVersion);
|
|
|
|
var tokens: TypeScript.ISyntaxToken[] = [];
|
|
var textArray: string[] = [];
|
|
var diagnostics: TypeScript.Diagnostic[] = [];
|
|
|
|
while (true) {
|
|
var token = scanner.scan(diagnostics, /*allowRegularExpression:*/ false);
|
|
tokens.push(token);
|
|
|
|
if (token.tokenKind === TypeScript.SyntaxKind.EndOfFileToken) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.checkResult(fileName, tokens, verify, generateBaseline, false);
|
|
}
|
|
|
|
runScanner(fileName: string, languageVersion: TypeScript.LanguageVersion, verify: boolean, generateBaseline: boolean): void {
|
|
if (!TypeScript.StringUtilities.endsWith(fileName, ".ts")) {
|
|
return;
|
|
}
|
|
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
|
|
var text = TypeScript.TextFactory.createText(contents);
|
|
var scanner = new TypeScript.Scanner(fileName, text, languageVersion);
|
|
|
|
var tokens: TypeScript.ISyntaxToken[] = [];
|
|
var textArray: string[] = [];
|
|
var diagnostics: TypeScript.Diagnostic[] = [];
|
|
|
|
while (true) {
|
|
var token = scanner.scan(diagnostics, /*allowRegularExpression:*/ false);
|
|
tokens.push(token);
|
|
|
|
if (token.tokenKind === TypeScript.SyntaxKind.EndOfFileToken) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (verify) {
|
|
var tokenText = TypeScript.ArrayUtilities.select(tokens, t => t.fullText()).join("");
|
|
|
|
if (tokenText !== contents) {
|
|
throw new Error("Token invariant broken!");
|
|
}
|
|
}
|
|
|
|
var result = diagnostics.length === 0 ? <any>tokens : { diagnostics: diagnostics, tokens: tokens };
|
|
this.checkResult(fileName, result, verify, generateBaseline, false);
|
|
}
|
|
|
|
parseArguments(): void {
|
|
TypeScript.Environment.standardOut.WriteLine("Testing input files.");
|
|
for (var index in TypeScript.Environment.arguments) {
|
|
var fileName: string = TypeScript.Environment.arguments[index];
|
|
if (specificFile !== undefined && fileName.indexOf(specificFile) < 0) {
|
|
continue;
|
|
}
|
|
|
|
this.runParser(fileName, TypeScript.LanguageVersion.EcmaScript5, /*verify:*/ false, /*generate:*/ false, /*allowErrors:*/ false);
|
|
}
|
|
}
|
|
|
|
run262(): void {
|
|
var path = "C:\\temp\\test262\\suite";
|
|
var testFiles = TypeScript.Environment.listFiles(path, null, { recursive: true });
|
|
|
|
var testCount = 0;
|
|
var failCount = 0;
|
|
var skippedTests:string[] = [];
|
|
|
|
for (var index in testFiles) {
|
|
var fileName: string = testFiles[index];
|
|
|
|
if (specificFile !== undefined && fileName.indexOf(specificFile) < 0) {
|
|
continue;
|
|
}
|
|
|
|
// All 262 files are utf8. But they dont' have a BOM. Force them to be read in
|
|
// as UTF8.
|
|
var contents = TypeScript.Environment.readFile(fileName, /*codepage*/ null).contents;
|
|
|
|
var isNegative = contents.indexOf("@negative") >= 0
|
|
|
|
testCount++;
|
|
|
|
try {
|
|
var stringText = TypeScript.TextFactory.createText(contents);
|
|
var tree = TypeScript.Parser.parse(fileName, stringText, TypeScript.isDTSFile(fileName), new TypeScript.ParseOptions(TypeScript.LanguageVersion.EcmaScript5, true));
|
|
|
|
if (isNegative) {
|
|
var nameOnly = fileName.substr(fileName.lastIndexOf("\\") + 1);
|
|
var canParseSuccessfully = negative262ExpectedResults[nameOnly];
|
|
|
|
if (canParseSuccessfully) {
|
|
// We expected to parse this successfully. Report an error if we didn't.
|
|
if (tree.diagnostics() && tree.diagnostics().length > 0) {
|
|
TypeScript.Environment.standardOut.WriteLine("Negative test. Unexpected failure: " + fileName);
|
|
failCount++;
|
|
}
|
|
}
|
|
else {
|
|
// We expected to fail on this. Report an error if we don't.
|
|
if (tree.diagnostics() === null || tree.diagnostics().length === 0) {
|
|
TypeScript.Environment.standardOut.WriteLine("Negative test. Unexpected success: " + fileName);
|
|
failCount++;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// Not a negative test. We can't have any errors or skipped tokens.
|
|
if (tree.diagnostics() && tree.diagnostics().length > 0) {
|
|
TypeScript.Environment.standardOut.WriteLine("Unexpected failure: " + fileName);
|
|
failCount++;
|
|
}
|
|
}
|
|
}
|
|
catch (e) {
|
|
failCount++;
|
|
this.handleException(fileName, e);
|
|
}
|
|
}
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("");
|
|
TypeScript.Environment.standardOut.WriteLine("Test 262 results:");
|
|
TypeScript.Environment.standardOut.WriteLine("Test Count: " + testCount);
|
|
TypeScript.Environment.standardOut.WriteLine("Skip Count: " + skippedTests.length);
|
|
TypeScript.Environment.standardOut.WriteLine("Fail Count: " + failCount);
|
|
|
|
for (var i = 0; i < skippedTests.length; i++) {
|
|
TypeScript.Environment.standardOut.WriteLine(skippedTests[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
var diagnostics: TypeScript.IIndexable<any> = {};
|
|
for (var d in TypeScript.LocalizedDiagnosticMessages) {
|
|
if (TypeScript.LocalizedDiagnosticMessages.hasOwnProperty(d)) {
|
|
var info: TypeScript.DiagnosticInfo = TypeScript.LocalizedDiagnosticMessages[d];
|
|
diagnostics[info.message] = { category: TypeScript.DiagnosticCategory[info.category], code: info.code };
|
|
}
|
|
}
|
|
|
|
var whatever = JSON.stringify(diagnostics, null, 4);
|
|
|
|
var totalTime = 0;
|
|
var totalSize = 0;
|
|
var program = new Program();
|
|
|
|
// New parser.
|
|
totalTime = 0;
|
|
totalSize = 0;
|
|
program.runAllTests(true);
|
|
|
|
var count = 1;
|
|
|
|
//for (var i = 0; i < count; i++) {
|
|
// program.parseArguments();
|
|
//}
|
|
|
|
TypeScript.Environment.standardOut.WriteLine("Total time: " + (totalTime / count));
|
|
TypeScript.Environment.standardOut.WriteLine("Total size: " + (totalSize / count)); |